{ "content": { "kind": "tabbed", "layout": "grid", "meta": { "subtitle": "The ontology is a queryable canon of software architecture. It holds every principle with its relations and its repair, every term with its definition, every algorithm with its contract, the reasoning that derives them, the layers they live in and how every tension between them is resolved, and every reference from one record to another is a link.", "title": "The Ontology", "version": "1.0.0" }, "tabs": [ { "icon": "bi-bounding-box", "id": "principles", "label": "Principles", "layout": "ontology", "sections": [ { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_big_ball_of_mud[\"Big Ball of Mud\"]\n n_god_object[\"God Object\"]\n n_concrete_coupling[\"Concrete Coupling\"]\n n_schema_drift[\"Schema Drift\"]\n n_implicit_contract[\"Implicit Contract\"]\n n_hardcoded_configuration[\"Hardcoded Configuration\"]\n n_shared_mutable_state[\"Shared Mutable State\"]\n n_boundary_leakage[\"Boundary Leakage\"]\n n_manual_only_governance[\"Manual-Only Governance\"]\n n_opaque_runtime_behavior[\"Opaque Runtime Behavior\"]\n n_unowned_risk[\"Unowned Risk\"]\n n_unobservable_failure[\"Unobservable Failure\"]\n n_unversioned_breaking_change[\"Unversioned Breaking Change\"]\n n_distributed_monolith[\"Distributed Monolith\"]\n n_shotgun_surgery[\"Shotgun Surgery\"]\n n_divergent_change[\"Divergent Change\"]\n n_feature_envy[\"Feature Envy\"]\n n_inappropriate_intimacy[\"Inappropriate Intimacy\"]\n n_message_chain[\"Message Chain\"]\n n_middle_man[\"Middle Man\"]\n n_data_clumps[\"Data Clumps\"]\n n_primitive_obsession[\"Primitive Obsession\"]\n n_stringly_typed_programming[\"Stringly Typed Programming\"]\n n_boolean_trap[\"Boolean Trap\"]\n n_long_parameter_list[\"Long Parameter List\"]\n n_magic_value[\"Magic Value\"]\n n_speculative_generality[\"Speculative Generality\"]\n n_premature_abstraction[\"Premature Abstraction\"]\n n_over_abstraction[\"Over-Abstraction\"]\n n_golden_hammer[\"Golden Hammer\"]\n n_pattern_cargo_cult[\"Pattern Cargo Cult\"]\n n_lava_flow[\"Lava Flow\"]\n n_zombie_code[\"Zombie Code\"]\n n_temporal_coupling[\"Temporal Coupling\"]\n n_hidden_side_effect[\"Hidden Side Effect\"]\n n_action_at_a_distance[\"Action at a Distance\"]\n n_ambient_context[\"Ambient Context\"]\n n_inconsistent_error_model[\"Inconsistent Error Model\"]\n n_exception_control_flow[\"Exception Control Flow\"]\n n_null_semantics_drift[\"Null Semantics Drift\"]\n n_anemic_domain_model[\"Anemic Domain Model\"]\n n_transaction_script_sprawl[\"Transaction Script Sprawl\"]\n n_fat_controller[\"Fat Controller\"]\n n_repository_dump[\"Repository Dump\"]\n n_utility_dump[\"Utility Dump\"]\n n_framework_leakage[\"Framework Leakage\"]\n n_vendor_lock_in_leakage[\"Vendor Lock-In Leakage\"]\n n_circular_dependency[\"Circular Dependency\"]\n n_cyclic_deployment_dependency[\"Cyclic Deployment Dependency\"]\n n_synchronous_chain_trap[\"Synchronous Chain Trap\"]\n n_chatty_interface[\"Chatty Interface\"]\n n_n_plus_one_query[\"N Plus One Query\"]\n n_cache_poisoning_by_design[\"Cache Poisoning by Design\"]\n n_retry_storm[\"Retry Storm\"]\n n_timeout_omission[\"Timeout Omission\"]\n n_missing_backpressure[\"Missing Backpressure\"]\n n_silent_data_corruption[\"Silent Data Corruption\"]\n n_lost_update[\"Lost Update\"]\n n_dual_write[\"Dual Write\"]\n n_read_your_writes_violation[\"Read-Your-Writes Violation\"]\n n_security_theater[\"Security Theater\"]\n n_authorization_scattering[\"Authorization Scattering\"]\n n_secret_sprawl[\"Secret Sprawl\"]\n n_personal_data_oversharing[\"Personal Data Oversharing\"]\n n_observability_noise[\"Observability Noise\"]\n n_log_as_control_flow[\"Log-as-Control-Flow\"]\n n_manual_runbook_dependency[\"Manual Runbook Dependency\"]\n n_big_bang_release[\"Big-Bang Release\"]\n n_irreversible_migration[\"Irreversible Migration\"]\n n_big_upfront_frozen_architecture[\"Big-Upfront Frozen Architecture\"]\n n_architecture_astronaut[\"Architecture Astronaut\"]\n n_feature_only_design[\"Feature-Only Design\"]\n n_test_pyramid_inversion[\"Test Pyramid Inversion\"]\n n_mock_mirage[\"Mock Mirage\"]\n n_flaky_test_normalization[\"Flaky Test Normalization\"]\n n_prompt_sprawl[\"Prompt Sprawl\"]\n n_ungrounded_content[\"Ungrounded Content\"]\n n_model_version_ambiguity[\"Model Version Ambiguity\"]" } ], "icon": "bi-collection", "id": "architecture-category-anti-patterns", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [state_transaction](/records/force/state-transaction)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a system has no discernible boundaries, so any part can depend on and change any other.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Modularity](/records/architecture/modularity), [Component-Based Architecture](/records/architecture/component-based-architecture), [Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" }, { "description": "[](/records/algorithms/architecture-anti-pattern)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow boundaries to remain implicit, permit unrestricted dependencies, mix concerns freely, share mutable state broadly, and accumulate changes without architectural segmentation.", "term": "Formed by" }, { "description": "[cyclic_dependencies](/records/architecture/circular-dependency), high_graph_density, unowned_modules, cross_layer_imports, large_change_blast_radius", "term": "Detected by" }, { "description": "dependency-cycle count, graph density, share of modules without an owner", "term": "Measured by" }, { "description": "[Define Module Boundaries](/records/lexicon/define-module-boundaries), [Split Module](/records/lexicon/split-module), [Architecture Test](/records/lexicon/architecture-test), [Assign Owner](/records/lexicon/assign-owner), [Fitness Functions](/records/architecture/fitness-functions)", "term": "Refactored by" }, { "description": "dependency rules, architecture fitness functions, module ownership map", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function handle(req) {\n const foo = db.query(req.body.sql);\n render(foo); email(foo); audit(foo); cache(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class CreateFoo {\n constructor(private readonly foos: FooRepository, private readonly events: EventPublisher) {}\n execute(input: CreateFooInput) { const foo = Foo.create(input); this.foos.save(foo); this.events.publish(fooCreated(foo)); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency rules, architecture fitness functions, module ownership map", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-big-ball-of-mud", "title": "Big Ball of Mud" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary), [control_coordination](/records/force/control-coordination)", "Aliases: Blob Class, God Class", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one object accumulates unrelated responsibilities and becomes the default place for every change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [High Cohesion](/records/architecture/high-cohesion)", "term": "Referenced by" }, { "description": "[Divergent Change](/records/architecture/divergent-change): A god object is one object holding many responsibilities, while divergent change is the symptom of one module changing for many reasons.", "term": "Distinct from" }, { "description": "[Shotgun Surgery](/records/architecture/shotgun-surgery): A god object concentrates responsibilities in one place, while shotgun surgery scatters one responsibility across many.", "term": "Distinct from" }, { "description": "[Utility Dump](/records/architecture/utility-dump): A god object is a domain object that absorbs every change, while a utility dump is a generic helper module that no one owns.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Centralize unrelated responsibilities into one object, route unrelated behavior through it, accumulate state and dependencies, and make the object the default modification point.", "term": "Formed by" }, { "description": "large_class, many_unrelated_methods, many_dependencies, high_fan_in, multiple_reasons_to_change", "term": "Detected by" }, { "description": "methods and dependencies per class, [fan-in](/records/lexicon/fan-in), distinct reasons to change", "term": "Measured by" }, { "description": "[Extract Class](/records/lexicon/extract-class), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Domain Service](/records/architecture/domain-service), [Facade Pattern](/records/architecture/facade-pattern)", "term": "Refactored by" }, { "description": "class size and responsibility limits in lint, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooManager {\n createFoo() {} priceFoo() {} renderFoo() {} emailFoo() {} auditFoo() {} shipFoo() {}\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooFactory { create(input: CreateFooInput): Foo {} }\nclass FooPricer { price(foo: Foo): Money {} }\nclass FooShipper { ship(foo: Foo): void {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "class size and responsibility limits in lint, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[God Object](/records/architecture/god-object)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-god-object", "title": "God Object" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Aliases: Concrete Dependency", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which high-level policy depends directly on concrete implementations instead of on abstractions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design), [Abstraction](/records/architecture/abstraction), [Replaceability](/records/architecture/replaceability), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion)", "term": "Referenced by" }, { "description": "[Middle Man](/records/architecture/middle-man): Concrete coupling depends on an implementation instead of an abstraction, while a middle man is a layer of indirection that adds nothing.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Let high-level policy depend directly on low-level implementations, vendor APIs, framework classes, or concrete constructors, then spread those concrete assumptions across the core.", "term": "Formed by" }, { "description": "domain_imports_infrastructure, vendor_sdk_in_core, new_dependency_inside_business_logic, missing_interface_boundary", "term": "Detected by" }, { "description": "concrete infrastructure imports in core modules", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface), [Introduce Port](/records/lexicon/introduce-port), [Extract Adapter](/records/lexicon/extract-adapter), [Dependency Injection](/records/architecture/dependency-injection), [Invert Dependency](/records/lexicon/invert-dependency)", "term": "Refactored by" }, { "description": "import rules that forbid infrastructure in the core, architecture tests", "term": "Enforced by" }, { "description": "concrete-coupling", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "class FooService {\n private readonly store = new SqlFooStore();\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {\n constructor(private readonly store: FooStore) {}\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules that forbid infrastructure in the core, architecture tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-concrete-coupling", "title": "Concrete Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which the producers, consumers and stores of one payload evolve its shape independently until its meaning diverges.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Data Contract](/records/architecture/data-contract), [Canonical Schema](/records/architecture/canonical-schema)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow producers, consumers, storage models, and documentation to evolve independently without versioned schema governance, then let payload meaning diverge over time.", "term": "Formed by" }, { "description": "schema_diff_failure, missing_schema_registry, consumer_parse_errors, undocumented_field_changes, nullability_mismatch", "term": "Detected by" }, { "description": "schema diff failures and consumer parse errors per release", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract), [Versioning](/records/architecture/versioning), [Contract Testing](/records/lexicon/contract-testing), [Schema Registry](/records/lexicon/schema-registry), [Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "[schema registry](/records/lexicon/schema-registry), compatibility tests in the build", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type FooApi = { id: string; label: string };\ntype FooDb = { id: string; name: string; extra: string };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FooSchema = schema({ id: fooIdSchema, name: nonEmptyString });\ntype Foo = Infer;\nfooApi.use(FooSchema);\nfooDb.use(FooSchema);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema registry, compatibility tests in the build", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-schema-drift", "title": "Schema Drift" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [causality_ordering](/records/force/causality-ordering)", "Aliases: Implicit Payloads", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a boundary's assumptions, including the shape and meaning of the data it passes, live in behavior, naming or ordering rather than in a declared contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Encode assumptions in code behavior, naming, ordering, timing, side effects, or undocumented payload shapes instead of declaring them as explicit contracts.", "term": "Formed by" }, { "description": "public_API_without_schema, undocumented_side_effect, dynamic_map_boundary, tests_depend_on_internal_behavior, tribal_knowledge_required", "term": "Detected by" }, { "description": "public operations without a declared schema", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract), [Precondition Check](/records/lexicon/precondition-check), [Postcondition Check](/records/lexicon/postcondition-check), [Schema Validation](/records/architecture/schema-validation), [Contract Testing](/records/lexicon/contract-testing)", "term": "Refactored by" }, { "description": "contract tests, schema validation at public boundaries", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo) { return db.insert(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface Foo { id: FooId; name: NonEmptyString; }\nfunction saveFoo(foo: Foo): Promise { return fooStore.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, schema validation at public boundaries", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Implicit Contract](/records/architecture/implicit-contract)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-implicit-contract", "title": "Implicit Contract" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [semantic_consistency](/records/force/semantic-consistency), [state_transaction](/records/force/state-transaction)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which environment, credential or policy values are written into code instead of being supplied as configuration.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization), [Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Embed environment, path, credential, feature, service endpoint, or policy values directly into code, then duplicate those assumptions across runtime contexts.", "term": "Formed by" }, { "description": "hardcoded_URL, hardcoded_path, hardcoded_secret, environment_branching_in_code, duplicated_config_literal", "term": "Detected by" }, { "description": "configuration literals and secrets found in source", "term": "Measured by" }, { "description": "[Externalize Configuration](/records/lexicon/externalize-configuration), [Configuration Schema](/records/lexicon/configuration-schema), [Centralized Configuration](/records/architecture/centralized-configuration), [Remove Secret from Code](/records/lexicon/remove-secret-from-code)", "term": "Refactored by" }, { "description": "configuration and secret scans, a configuration schema validated at startup", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const client = new FooClient(\"https://foo.prod.example\", \"sk_live_abc123\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const config = FooConfigSchema.parse({ url: process.env.FOO_URL, key: process.env.FOO_KEY });\nconst client = new FooClient(config);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "configuration and secret scans, a configuration schema validated at startup", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-hardcoded-configuration", "title": "Hardcoded Configuration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [state_transaction](/records/force/state-transaction)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which writable state is shared across modules with no owner and no synchronization.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Immutability](/records/architecture/immutability), [State Isolation](/records/architecture/state-isolation)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Expose writable state across modules, allow multiple actors to mutate it, omit ownership and synchronization, and let behavior depend on mutation order.", "term": "Formed by" }, { "description": "global_mutable_object, public_mutable_fields, shared_cache_without_policy, race_condition, order_dependent_tests", "term": "Detected by" }, { "description": "writable state reachable from more than one module, race-detector findings", "term": "Measured by" }, { "description": "[Encapsulate State](/records/lexicon/encapsulate-state), [Assign Owner](/records/lexicon/assign-owner), [Make Immutable](/records/lexicon/make-immutable), [Introduce Transaction Boundary](/records/lexicon/introduce-transaction-boundary), [Apply Concurrency Control](/records/lexicon/apply-concurrency-control)", "term": "Refactored by" }, { "description": "immutability and visibility lint rules, concurrency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "let currentFoo = null;\nfunction setFoo(f) { currentFoo = f; }\nfunction useFoo() { return currentFoo.name; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooContext {\n constructor(private readonly foo: Foo) {}\n name() { return this.foo.name; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "immutability and visibility lint rules, concurrency tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-shared-mutable-state", "title": "Shared Mutable State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which internal, persistence or vendor types cross an architectural boundary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Permit internal models, infrastructure types, persistence structures, or private module APIs to cross intended architectural boundaries.", "term": "Formed by" }, { "description": "internal_package_imported_externally, database_entity_exposed_as_API, vendor_type_in_domain, private_module_used_by_other_module", "term": "Detected by" }, { "description": "internal types exposed across boundaries", "term": "Measured by" }, { "description": "[Restrict Exports](/records/lexicon/restrict-exports), [Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto), [Extract Adapter](/records/lexicon/extract-adapter), [Facade Pattern](/records/architecture/facade-pattern), [Architecture Test](/records/lexicon/architecture-test)", "term": "Refactored by" }, { "description": "export and import restrictions, boundary architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/foo/:id\", async (req, res) => res.json(await ormFoo.findByPk(req.params.id)));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.get(\"/foo/:id\", async (req, res) => res.json(toFooDto(await getFoo.execute(req.params.id))));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "export and import restrictions, boundary architecture tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Boundary Leakage](/records/architecture/boundary-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-boundary-leakage", "title": "Boundary Leakage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "Aliases: Document-Only Policy", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which architecture rules or security policies exist only in documents or in reviewers' memory, with no executable check, so they drift from what the system does.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Policy as Code](/records/architecture/policy-as-code)", "term": "Referenced by" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "Encode architecture rules in documents, meetings, or reviewer memory without executable checks, metrics, or automated enforcement.", "term": "Formed by" }, { "description": "rule_exists_only_in_docs, no_CI_gate, reviewer_specific_enforcement, repeated_same_violation, missing_fitness_function", "term": "Detected by" }, { "description": "stated rules without an executable check, repeat violations of one rule", "term": "Measured by" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions), [Static Analysis](/records/architecture/static-analysis), [Policy as Code](/records/architecture/policy-as-code), [Architecture Test](/records/lexicon/architecture-test), [Track Rule Metrics](/records/lexicon/track-rule-metrics)", "term": "Refactored by" }, { "description": "a rule-coverage check that requires every stated rule to name its executable gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const CONVENTION = \"remember to prefix every foo id with foo_\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const rule = { id: \"valid-foo-id\", check: (id: string) => id.startsWith(\"foo_\") };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a rule-coverage check that requires every stated rule to name its executable gate", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-manual-only-governance", "title": "Manual-Only Governance" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [runtime_extensibility](/records/force/runtime-extensibility), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "Aliases: Opaque Runtime", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which runtime behavior emerges from hidden reflection, registration or binding that nothing reports, so the runtime's structure and state cannot be inspected.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Introspection](/records/architecture/introspection)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Let runtime behavior emerge from hidden reflection, implicit registration, undocumented configuration, side effects, or untraced dynamic binding.", "term": "Formed by" }, { "description": "dynamic_binding_without_manifest, missing_startup_report, unlogged_plugin_loading, implicit_reflection_scan, untraceable_side_effect", "term": "Detected by" }, { "description": "dynamic bindings without a manifest entry", "term": "Measured by" }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design), [Binding Decision Log](/records/lexicon/binding-decision-log), [Runtime Topology Report](/records/lexicon/runtime-topology-report), [Declare Capability](/records/lexicon/declare-capability), [Discovery Validation](/records/lexicon/discovery-validation)", "term": "Refactored by" }, { "description": "manifest validation, a startup report that lists every binding", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(foo) { doWork(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function processFoo(foo: Foo) {\n logger.info(\"foo.process.start\", { fooId: foo.id });\n const result = doWork(foo);\n logger.info(\"foo.process.done\", { fooId: foo.id, outcome: result.status });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "manifest validation, a startup report that lists every binding", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-opaque-runtime-behavior", "title": "Opaque Runtime Behavior" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: Unknown/Unowned Risk", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a risk is never identified, or is identified and has no owner, severity, mitigation or review date.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Identify a risk without assigning owner, severity, mitigation, review date, acceptance status, or escalation path.", "term": "Formed by" }, { "description": "risk_without_owner, ADR_missing_consequence_owner, security_finding_unassigned, known_gap_without_due_date, accepted_risk_without_expiry", "term": "Detected by" }, { "description": "risks without an owner, reviews past their date", "term": "Measured by" }, { "description": "[Assign Owner](/records/lexicon/assign-owner), [Severity Classification](/records/lexicon/severity-classification), [Mitigation Plan](/records/lexicon/mitigation-plan), [Accepted Risk Record](/records/lexicon/accepted-risk-record), [Scheduled Review](/records/lexicon/scheduled-review)", "term": "Refactored by" }, { "description": "a risk register whose entries are validated for owner, severity and review date", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "risks.push({ title: \"the foo store has no backup\" });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "risks.push({ title: \"the foo store has no backup\", owner: \"storage team\", severity: \"high\", mitigation: \"nightly snapshot\", reviewBy: \"2026-12-01\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a risk register whose entries are validated for owner, severity and review date", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-unowned-risk", "title": "Unowned Risk" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility)", "Aliases: Opaque System", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an operation can fail without leaving a log, metric, trace or error contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Observability](/records/architecture/observability)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Permit operations to fail without structured logs, metrics, alerts, traces, audit records, or user-visible error contracts.", "term": "Formed by" }, { "description": "empty_catch, swallowed_exception, missing_error_log, no_alert_on_critical_path, missing_trace_span, missing_audit_record", "term": "Detected by" }, { "description": "swallowed exceptions, critical paths without error telemetry", "term": "Measured by" }, { "description": "[Error Boundaries](/records/architecture/error-boundaries), [Structured Log](/records/lexicon/structured-log), [Metrics](/records/lexicon/metrics), [Alert on Critical Failure](/records/lexicon/alert-on-critical-failure), [Trace Span](/records/lexicon/trace-span), [Audit Logging](/records/architecture/audit-logging)", "term": "Refactored by" }, { "description": "lint rules against empty and swallowing catch blocks, telemetry coverage checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "try { await ship(foo); } catch { }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "try { await ship(foo); } catch (error) { logger.error(\"foo.ship.failed\", error); metrics.increment(\"foo.ship.failure\"); throw new ShipFailedError(foo.id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules against empty and swallowing catch blocks, telemetry coverage checks", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-unobservable-failure", "title": "Unobservable Failure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [event_messaging](/records/force/event-messaging), [architecture_evolution](/records/force/architecture-evolution)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a public contract changes incompatibly without a version, a deprecation path or a compatibility test.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Change a public API, schema, event, protocol, behavior, or package contract incompatibly without version bump, deprecation path, compatibility test, or migration notice.", "term": "Formed by" }, { "description": "API_diff_breaking, schema_field_removed, type_narrowed, event_semantics_changed, no_version_bump, no_deprecation_window", "term": "Detected by" }, { "description": "breaking diffs released without a version bump", "term": "Measured by" }, { "description": "[Version Bump](/records/lexicon/version-bump), [Compatibility Adapter](/records/lexicon/compatibility-adapter), [Gradual Deprecation](/records/lexicon/gradual-deprecation), [Contract Testing](/records/lexicon/contract-testing), [Migration Guide](/records/lexicon/migration-guide)", "term": "Refactored by" }, { "description": "API and schema diff gates in the release pipeline", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/foo\", () => ({ label: foo.name }));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.get(\"/v2/foo\", () => ({ name: foo.name }));\napp.get(\"/v1/foo\", () => ({ label: foo.name }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API and schema diff gates in the release pipeline", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-unversioned-breaking-change", "title": "Unversioned Breaking Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [state_transaction](/records/force/state-transaction)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which services are deployed separately but still share data, transactions and release cycles.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Microservices](/records/architecture/microservices)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Split deployment units without splitting data ownership, transaction boundaries, failure isolation, contracts, or autonomous release capability.", "term": "Formed by" }, { "description": "[shared_database](/records/lexicon/shared-database), cross_service_transactions, lockstep_deployments, deep_sync_call_chain, shared_business_logic_package, consumer_breakage_on_service_change", "term": "Detected by" }, { "description": "shared databases, lockstep deployments, cross-service transactions", "term": "Measured by" }, { "description": "[Own Data per Service](/records/lexicon/own-data-per-service), [Define Contract](/records/lexicon/define-contract), [Domain Events](/records/architecture/domain-events), [Outbox Pattern](/records/architecture/outbox-pattern), [Split Bounded Context](/records/lexicon/split-bounded-context), [Backward-Compatible Change](/records/lexicon/backward-compatible-change)", "term": "Refactored by" }, { "description": "service-ownership rules, contract tests, independent-deployment checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function createFoo(foo) {\n await http.post(\"bar-service/validate\", foo);\n await http.post(\"baz-service/price\", foo);\n await http.post(\"qux-service/save\", foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function createFoo(input: CreateFooInput) {\n const foo = Foo.create(input);\n await fooStore.save(foo);\n await outbox.append(fooCreated(foo));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "service-ownership rules, contract tests, independent-deployment checks", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Distributed Monolith](/records/architecture/distributed-monolith)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-distributed-monolith", "title": "Distributed Monolith" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one responsibility is scattered so that a single change needs edits in many files.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[High Cohesion](/records/architecture/high-cohesion)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Scatter one conceptual responsibility across many files so one change requires many coordinated edits.", "term": "Formed by" }, { "description": "same_change_touches_many_files, repeated_commit_cochanges, duplicated_rule_fragments", "term": "Detected by" }, { "description": "files touched per logical change, co-change frequency", "term": "Measured by" }, { "description": "[Centralize the Rule](/records/lexicon/centralize-the-rule), [Extract Module](/records/lexicon/extract-module), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner)", "term": "Refactored by" }, { "description": "duplication detection, change-coupling review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const taxA = value * 0.2;\nconst taxB = other * 0.2;\nconst taxC = more * 0.2;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FOO_TAX_RATE = 0.2;\nfunction taxFoo(value: number) { return value * FOO_TAX_RATE; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "duplication detection, change-coupling review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Shotgun Surgery](/records/architecture/shotgun-surgery)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-shotgun-surgery", "title": "Shotgun Surgery" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one module changes for many unrelated reasons.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Place unrelated responsibilities in the same module so unrelated change reasons repeatedly modify one artifact.", "term": "Formed by" }, { "description": "unrelated_commits_touch_same_file, mixed_methods, mixed_dependencies", "term": "Detected by" }, { "description": "distinct reasons to change per module in the change history", "term": "Measured by" }, { "description": "[Split Module](/records/lexicon/split-module), [Extract Class](/records/lexicon/extract-class), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner)", "term": "Refactored by" }, { "description": "module cohesion limits, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class Foo {\n renderHtml() {} saveToSql() {} sendEmail() {} parseCsv() {}\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {}\nclass FooView { render(foo: Foo): string {} }\nclass FooStore { save(foo: Foo): Promise {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "module cohesion limits, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Divergent Change](/records/architecture/divergent-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-divergent-change", "title": "Divergent Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one module mostly works on another module's data instead of its own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Let one module repeatedly inspect or manipulate another module’s data instead of moving behavior to the data owner.", "term": "Formed by" }, { "description": "many_getters_from_other_object, logic_using_foreign_fields, domain_rule_outside_owner", "term": "Detected by" }, { "description": "foreign field accesses per method", "term": "Measured by" }, { "description": "[Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Encapsulate State](/records/lexicon/encapsulate-state), [Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Extract Use Case](/records/lexicon/extract-use-case)", "term": "Refactored by" }, { "description": "coupling analysis in lint, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function totalFoo(bar: Bar) { return bar.items.reduce((s, i) => s + i.price * i.qty, 0); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Bar { total(): Money { return this.items.reduce((s, i) => s + i.subtotal(), 0); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coupling analysis in lint, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Feature Envy](/records/architecture/feature-envy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-feature-envy", "title": "Feature Envy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which modules depend on each other's internal structure or private state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Referenced by" }, { "description": "[Message Chain](/records/architecture/message-chain): Inappropriate intimacy reads another module's internals, while a message chain navigates a chain of public references.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow modules or classes to rely on each other’s internals, private structure, lifecycle, or undocumented state.", "term": "Formed by" }, { "description": "friend-like access, private API usage, tests_reach_internals, internal_package_import", "term": "Detected by" }, { "description": "private-member accesses across modules", "term": "Measured by" }, { "description": "[Restrict Exports](/records/lexicon/restrict-exports), [Define Contract](/records/lexicon/define-contract), [Facade Pattern](/records/architecture/facade-pattern)", "term": "Refactored by" }, { "description": "visibility and export rules, tests limited to public interfaces", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "bar.foo._internalState.status = \"ready\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "bar.foo.markReady();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "visibility and export rules, tests limited to public interfaces", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Inappropriate Intimacy](/records/architecture/inappropriate-intimacy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-inappropriate-intimacy", "title": "Inappropriate Intimacy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [event_messaging](/records/force/event-messaging)", "Aliases: Train Wreck", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a client navigates a chain of objects to reach the behavior it needs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Require clients to traverse a chain of objects to reach behavior or data, exposing internal object graph structure.", "term": "Formed by" }, { "description": "a.getB().getC().doX, deep_property_access, repeated_navigation_paths", "term": "Detected by" }, { "description": "member-access chain depth at call sites", "term": "Measured by" }, { "description": "[Hide Delegate](/records/lexicon/hide-delegate), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner)", "term": "Refactored by" }, { "description": "a lint rule on member-access chain depth", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const city = foo.getOwner().getAddress().getCity().getName();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const city = foo.ownerCityName();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule on member-access chain depth", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Message Chain](/records/architecture/message-chain)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-message-chain", "title": "Message Chain" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [control_coordination](/records/force/control-coordination)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a module delegates almost every call without adding behavior of its own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Abstraction](/records/architecture/abstraction)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Insert a module that delegates almost everything without adding policy, abstraction, validation, orchestration, or simplification.", "term": "Formed by" }, { "description": "thin_methods_only_delegate, low_logic_density, one_to_one_wrapper_methods", "term": "Detected by" }, { "description": "share of methods that only delegate", "term": "Measured by" }, { "description": "[Collapse Layers](/records/lexicon/collapse-layers), [Inline Abstraction](/records/lexicon/inline-abstraction), [Facade Pattern](/records/architecture/facade-pattern)", "term": "Refactored by" }, { "description": "delegation-ratio analysis, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n save(foo: Foo) { return this.store.save(foo); }\n find(id: FooId) { return this.store.find(id); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooStore: FooStore = new SqlFooStore();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "delegation-ratio analysis, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Middle Man](/records/architecture/middle-man)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-middle-man", "title": "Middle Man" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which the same group of values travels together without being named as one type.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" }, { "description": "[Long Parameter List](/records/architecture/long-parameter-list): Data clumps are one group of values traveling together unnamed, while a long parameter list is one signature with too many parameters of any kind.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Pass the same group of fields together repeatedly without naming the group as a value object or contract.", "term": "Formed by" }, { "description": "same_parameters_repeated, same_fields_appear_together, DTO_shape_duplicated", "term": "Detected by" }, { "description": "repeated parameter groups across signatures", "term": "Measured by" }, { "description": "[Value Object](/records/architecture/value-object), [Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto), [Name the Concept](/records/lexicon/name-the-concept), [Validate as a Group](/records/lexicon/validate-as-a-group)", "term": "Refactored by" }, { "description": "duplicate parameter-group detection in lint", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function shipFoo(street: string, city: string, zip: string, country: string) {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface Address { street: string; city: string; zip: string; country: string; }\nfunction shipFoo(address: Address) {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "duplicate parameter-group detection in lint", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Data Clumps](/records/architecture/data-clumps)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-data-clumps", "title": "Data Clumps" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which domain concepts are held in raw primitives with no type or validation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" }, { "description": "[Data Clumps](/records/architecture/data-clumps): Primitive obsession holds one concept in a raw primitive, while data clumps are several values that belong together as one type.", "term": "Distinct from" }, { "description": "[Long Parameter List](/records/architecture/long-parameter-list): Primitive obsession is about the type of one value, while a long parameter list is about the number of parameters in one signature.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Represent meaningful domain concepts as raw strings, numbers, booleans, or maps without type, validation, or behavior.", "term": "Formed by" }, { "description": "many_string_ids, repeated_validation, boolean_flags, magic_values", "term": "Detected by" }, { "description": "domain concepts held in primitive types", "term": "Measured by" }, { "description": "[Value Object](/records/architecture/value-object), [Narrow Type](/records/lexicon/narrow-type), [Replace Boolean with Enum](/records/lexicon/replace-boolean-with-enum), [Encapsulate Validation](/records/lexicon/encapsulate-validation)", "term": "Refactored by" }, { "description": "type checks and a lint rule against primitive-typed domain identifiers", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function transfer(fooId: string, amount: number, currency: string) {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Money { constructor(readonly amount: number, readonly currency: Currency) {} }\nfunction transfer(fooId: FooId, money: Money) {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "type checks and a lint rule against primitive-typed domain identifiers", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Primitive Obsession](/records/architecture/primitive-obsession)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-primitive-obsession", "title": "Primitive Obsession" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which states, types or permissions are encoded as unchecked strings.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Type Safety](/records/architecture/type-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Encode behavior, types, states, permissions, or protocols as unchecked strings.", "term": "Formed by" }, { "description": "string_mode_switch, repeated_string_constants, string_permissions, string_status_values", "term": "Detected by" }, { "description": "string comparisons against values of a closed set", "term": "Measured by" }, { "description": "[Replace Boolean with Enum](/records/lexicon/replace-boolean-with-enum), [Introduce Discriminated Union](/records/lexicon/introduce-discriminated-union), [Centralize the Rule](/records/lexicon/centralize-the-rule), [Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "lint rules that require an enum or a discriminated union for a closed set", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (foo.status === \"reddy\") ship(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "enum FooStatus { Ready, Shipped }\nif (foo.status === FooStatus.Ready) ship(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules that require an enum or a discriminated union for a closed set", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Stringly Typed Programming](/records/architecture/stringly-typed-programming)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-stringly-typed-programming", "title": "Stringly Typed Programming" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: Flag Argument", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which boolean parameters hide the intent of a call site.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Use boolean parameters or flags that hide intent and create ambiguous call sites or combinatorial behavior.", "term": "Formed by" }, { "description": "method(true,false), multiple_boolean_params, flag_argument_controls_behavior", "term": "Detected by" }, { "description": "calls that pass more than one boolean literal", "term": "Measured by" }, { "description": "[Replace Boolean with Enum](/records/lexicon/replace-boolean-with-enum), [Split Method](/records/lexicon/split-method), [Introduce Parameter Object](/records/lexicon/introduce-parameter-object), [Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "a lint rule against positional boolean parameters", "term": "Enforced by" }, { "description": "boolean-trap", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "createFoo(true, false, true);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "createFoo({ active: true, archived: false, notify: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule against positional boolean parameters", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Boolean Trap](/records/architecture/boolean-trap)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-boolean-trap", "title": "Boolean Trap" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [object_creation](/records/force/object-creation)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a signature grows so many parameters that a caller can no longer read or validate it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Grow function or constructor signatures until related inputs, optional modes, and dependencies become hard to understand or validate.", "term": "Formed by" }, { "description": "arity_above_threshold, repeated_parameter_groups, many_optional_params", "term": "Detected by" }, { "description": "parameters per signature above the threshold", "term": "Measured by" }, { "description": "[Introduce Parameter Object](/records/lexicon/introduce-parameter-object), [Builder Pattern](/records/architecture/builder-pattern), [Value Object](/records/architecture/value-object), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "a lint rule on parameter count", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function makeFoo(a, b, c, d, e, f, g) {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface MakeFooInput { a: A; b: B; c: C; d: D; e: E; f: F; g: G; }\nfunction makeFoo(input: MakeFooInput) {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule on parameter count", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Long Parameter List](/records/architecture/long-parameter-list)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-long-parameter-list", "title": "Long Parameter List" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [domain_boundary](/records/force/domain-boundary)", "Aliases: Magic Number", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which policy, thresholds or states are written as unexplained literals.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Encode policy, thresholds, status, timing, permissions, or domain rules as unexplained literals.", "term": "Formed by" }, { "description": "repeated_number_literal, unexplained_string_literal, inline_threshold, hidden_timeout", "term": "Detected by" }, { "description": "unnamed literals in conditions", "term": "Measured by" }, { "description": "[Name Constant](/records/lexicon/name-constant), [Centralize the Rule](/records/lexicon/centralize-the-rule), [Externalize Configuration](/records/lexicon/externalize-configuration), [Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "a lint rule against unnamed numeric and string literals in logic", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (foo.retries > 3) fail(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const MAX_FOO_RETRIES = 3;\nif (foo.retries > MAX_FOO_RETRIES) fail(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule against unnamed numeric and string literals in logic", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Magic Value](/records/architecture/magic-value)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-magic-value", "title": "Magic Value" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [runtime_extensibility](/records/force/runtime-extensibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which abstractions are built for variation that has no evidence of arriving.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Build abstractions, extension points, layers, or configuration for variation that has no evidence of existing or near-term need.", "term": "Formed by" }, { "description": "single_implementation_interface, unused_extension_point, config_never_varies, abstract_base_without_variants", "term": "Detected by" }, { "description": "interfaces with one implementation, unused extension points", "term": "Measured by" }, { "description": "[Inline Abstraction](/records/lexicon/inline-abstraction), [Defer Generalization](/records/lexicon/defer-generalization), [Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Refactored by" }, { "description": "dead-code and single-implementation analysis, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "abstract class AbstractFooProviderFactoryBase { abstract create(): T; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function createFoo(input: CreateFooInput): Foo { return Foo.create(input); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dead-code and single-implementation analysis, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Speculative Generality](/records/architecture/speculative-generality)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-speculative-generality", "title": "Speculative Generality" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a shared abstraction is extracted before its variation is understood, so it fits no caller well.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Contracts" }, { "description": "[Zombie Code](/records/architecture/zombie-code): Premature abstraction extracts shared code too early, while zombie code leaves dead code in place.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Extract a shared abstraction before variation is understood, causing the abstraction to fit no use case well.", "term": "Formed by" }, { "description": "many_flags_in_shared_abstraction, subclasses_override_most_behavior, callers_work_around_abstraction", "term": "Detected by" }, { "description": "flags and overrides per shared abstraction", "term": "Measured by" }, { "description": "[Duplicate Until the Pattern Stabilizes](/records/lexicon/duplicate-until-the-pattern-stabilizes), [Split Abstraction](/records/lexicon/split-abstraction), [Defer Generalization](/records/lexicon/defer-generalization)", "term": "Refactored by" }, { "description": "design review against evidence of recurrence", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "interface FooStrategy { run(): void; }\nclass OnlyFooStrategy implements FooStrategy { run() {} }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function runFoo() {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review against evidence of recurrence", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Premature Abstraction](/records/architecture/premature-abstraction)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-premature-abstraction", "title": "Premature Abstraction" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which layers, interfaces and factories outnumber the variation they serve.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" }, { "description": "[Speculative Generality](/records/architecture/speculative-generality): Over-abstraction is the state of having more layers than variation, while speculative generality is the cause, building for variation not yet seen.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Add too many interfaces, layers, factories, adapters, or generic types relative to actual variability.", "term": "Formed by" }, { "description": "deep_call_stack_for_simple_task, one_method_interfaces, factory_of_factory, abstraction_ratio_too_high", "term": "Detected by" }, { "description": "indirection depth for simple operations, abstraction-to-implementation ratio", "term": "Measured by" }, { "description": "[Collapse Layers](/records/lexicon/collapse-layers), [Inline Abstraction](/records/lexicon/inline-abstraction), [Preserve Only Real Boundaries](/records/lexicon/preserve-only-real-boundaries)", "term": "Refactored by" }, { "description": "abstraction-ratio analysis, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = fooFactoryProvider.getFactory().createBuilder().build();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = Foo.create(input);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "abstraction-ratio analysis, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Over-Abstraction](/records/architecture/over-abstraction)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-over-abstraction", "title": "Over-Abstraction" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: Law of the Instrument", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one familiar solution is applied to problems regardless of fit.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Apply a familiar pattern, framework, architecture style, or technology to problems regardless of fit.", "term": "Formed by" }, { "description": "same_pattern_everywhere, solution_precedes_problem, ADR_missing_alternatives, high_workaround_count", "term": "Detected by" }, { "description": "decisions recorded without alternatives", "term": "Measured by" }, { "description": "[Force Analysis](/records/lexicon/force-analysis), [Trade-Off Matrix](/records/lexicon/trade-off-matrix), [Decision Record with Alternatives](/records/lexicon/decision-record-with-alternatives), [Contextual Pattern Selection](/records/lexicon/contextual-pattern-selection)", "term": "Refactored by" }, { "description": "decision records that require alternatives and the forces they answer", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const config = parseFooConfig(runRegexOverEverything(rawYaml));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const config = FooConfigSchema.parse(yaml.load(rawYaml));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "decision records that require alternatives and the forces they answer", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Golden Hammer](/records/architecture/golden-hammer)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-golden-hammer", "title": "Golden Hammer" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "Aliases: Cargo-Cult Pattern Use", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a pattern's name and shape are copied without the forces, contracts and checks that make it work.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Referenced by" }, { "description": "[Golden Hammer](/records/architecture/golden-hammer): A cargo cult copies a pattern's shape without its forces, while a golden hammer applies one familiar solution to every problem.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Copy named patterns or architecture styles without implementing their required forces, contracts, constraints, or validation gates.", "term": "Formed by" }, { "description": "ports_without_boundary_rules, plugins_without_contracts, events_without_idempotency, microservices_without_autonomy", "term": "Detected by" }, { "description": "patterns missing their required boundary rules or contracts", "term": "Measured by" }, { "description": "[Validate Required Forces](/records/lexicon/validate-required-forces), [Define Contract](/records/lexicon/define-contract), [Name the Concept](/records/lexicon/name-the-concept), [Remove Pattern Shell](/records/lexicon/remove-pattern-shell)", "term": "Refactored by" }, { "description": "architecture tests that check each named pattern's required contracts", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooSingletonFactoryObserverProxy {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService { constructor(private readonly store: FooStore) {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests that check each named pattern's required contracts", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Pattern Cargo Cult](/records/architecture/pattern-cargo-cult)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pattern-cargo-cult", "title": "Pattern Cargo Cult" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which obsolete or half-migrated code survives because nothing records whether it is still needed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" }, { "description": "[Premature Abstraction](/records/architecture/premature-abstraction): Lava flow is obsolete code kept too long, while premature abstraction is shared code extracted too early.", "term": "Distinct from" }, { "description": "[Zombie Code](/records/architecture/zombie-code): Lava flow is code that may still run and whose purpose nobody records, while zombie code is unreachable or disabled.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Preserve obsolete, half-migrated, or unexplained code paths because no record says whether they are still needed.", "term": "Formed by" }, { "description": "old_paths_never_called, deprecated_code_without_removal_date, feature_flags_stuck_on_or_off, comments_say_do_not_touch", "term": "Detected by" }, { "description": "code paths with no runtime hits, deprecated code past its removal date", "term": "Measured by" }, { "description": "[Usage Instrumentation](/records/lexicon/usage-instrumentation), [Assign Owner](/records/lexicon/assign-owner), [Deprecation Plan](/records/lexicon/deprecation-plan), [Delete After Evidence](/records/lexicon/delete-after-evidence)", "term": "Refactored by" }, { "description": "dead-code analysis, removal dates on deprecated paths", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo) {\n legacySaveV1(foo);\n if (false) legacySaveV2(foo);\n newSave(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function saveFoo(foo: Foo) { return fooStore.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dead-code analysis, removal dates on deprecated paths", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Lava Flow](/records/architecture/lava-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-lava-flow", "title": "Lava Flow" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: Dead Code", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which unreachable or disabled code stays in the system and misleads the developer and the model.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Leave unreachable, unused, or disabled code in the system where it keeps misleading the developer and the model, and can be reactivated by accident.", "term": "Formed by" }, { "description": "unused_exports, unreachable_branches, dead_feature_flags, zero_runtime_hits", "term": "Detected by" }, { "description": "unused exports, unreachable branches", "term": "Measured by" }, { "description": "[Delete After Evidence](/records/lexicon/delete-after-evidence), [Archive Reference](/records/lexicon/archive-reference), [Restrict Exports](/records/lexicon/restrict-exports), [Dead Code Check](/records/lexicon/dead-code-check)", "term": "Refactored by" }, { "description": "unused-export and unreachable-code checks in the build", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function computeFoo() {}\nfunction computeFooOld() {}\nfunction computeFooDeprecated() {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function computeFoo() {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "unused-export and unreachable-code checks in the build", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Zombie Code](/records/architecture/zombie-code)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-zombie-code", "title": "Zombie Code" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [causality_ordering](/records/force/causality-ordering)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which operations must be called in an undocumented order to work.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Statelessness](/records/architecture/statelessness)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Require operations to be called in a specific undocumented order for correctness.", "term": "Formed by" }, { "description": "must_call_initialize_first, method_fails_before_setup, order_dependent_tests, state_machine_hidden_in_calls", "term": "Detected by" }, { "description": "operations that fail when called out of order", "term": "Measured by" }, { "description": "[Encode State Machine](/records/lexicon/encode-state-machine), [Constructor-Valid State](/records/lexicon/constructor-valid-state), [Make Order Explicit](/records/lexicon/make-order-explicit), [Precondition Check](/records/lexicon/precondition-check)", "term": "Refactored by" }, { "description": "types or constructors that only produce valid states, precondition checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.init();\nfoo.configure();\nfoo.start();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = Foo.start(config);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "types or constructors that only produce valid states, precondition checks", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-temporal-coupling", "title": "Temporal Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [event_messaging](/records/force/event-messaging)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an operation that looks like a query mutates state or performs I/O that its name and signature do not show.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" }, { "description": "[Action at a Distance](/records/architecture/action-at-a-distance): A hidden side effect is a query that writes, while action at a distance is one part changing behavior elsewhere through globals or listeners.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Make an operation appear like a query or pure function while it mutates state, performs I/O, emits events, or changes global context.", "term": "Formed by" }, { "description": "getter_mutates_state, query_writes, function_emits_event_unexpectedly, global_context_modified", "term": "Detected by" }, { "description": "queries that write or emit", "term": "Measured by" }, { "description": "[Separate Query from Command](/records/lexicon/separate-query-from-command), [Make Effects Explicit](/records/lexicon/make-effects-explicit)", "term": "Refactored by" }, { "description": "command–query separation rules in lint, effect-boundary review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function getFoo(id: FooId) { audit.log(id); return fooStore.find(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function getFoo(id: FooId) { return fooStore.find(id); }\nfunction auditFooAccess(id: FooId) { audit.log(id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "command–query separation rules in lint, effect-boundary review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-hidden-side-effect", "title": "Hidden Side Effect" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [event_messaging](/records/force/event-messaging)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one part of the system changes behavior elsewhere through globals, patches or implicit listeners.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Let one part of the system change behavior far away through globals, monkey patches, shared registries, ambient context, or implicit event listeners.", "term": "Formed by" }, { "description": "monkey_patch, global_registry_mutation, ambient_context_write, implicit_subscriber_side_effect", "term": "Detected by" }, { "description": "global mutations and implicit listener registrations", "term": "Measured by" }, { "description": "[Explicit Dependency](/records/lexicon/explicit-dependency), [Localize Effect](/records/lexicon/localize-effect), [Causation Tracing](/records/lexicon/causation-tracing), [Restrict Global Mutation](/records/lexicon/restrict-global-mutation)", "term": "Refactored by" }, { "description": "lint rules against global mutation and monkey patching", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "globalThis.fooFlag = true;\nfunction runFoo() { if (globalThis.fooFlag) go(); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function runFoo(options: { enabled: boolean }) { if (options.enabled) go(); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules against global mutation and monkey patching", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Action at a Distance](/records/architecture/action-at-a-distance)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-action-at-a-distance", "title": "Action at a Distance" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [state_transaction](/records/force/state-transaction)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which request, tenant or user state is read from implicit global context.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Read user, tenant, locale, transaction, permissions, or request state from implicit global context instead of explicit parameters or scoped context objects.", "term": "Formed by" }, { "description": "global_current_user, thread_local_business_data, implicit_tenant_lookup, hidden_transaction_context", "term": "Detected by" }, { "description": "global context reads outside infrastructure code", "term": "Measured by" }, { "description": "[Pass Context Explicitly](/records/lexicon/pass-context-explicitly)", "term": "Refactored by" }, { "description": "lint rules against global context reads in business logic", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo) { return CurrentTenant.get().db.save(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function saveFoo(foo: Foo, tenant: Tenant) { return tenant.db.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules against global context reads in business logic", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Ambient Context](/records/architecture/ambient-context)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-ambient-context", "title": "Ambient Context" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one class of failure is reported through several incompatible shapes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Mix exceptions, nulls, booleans, strings, partial objects, console logging, and silent failure for the same error class.", "term": "Formed by" }, { "description": "same_error_returns_null_or_throws, mixed_error_shapes, string_errors, partial_success_without_contract", "term": "Detected by" }, { "description": "distinct error shapes per error class", "term": "Measured by" }, { "description": "[Introduce Typed Result](/records/lexicon/introduce-typed-result), [Standard Error Contract](/records/lexicon/standard-error-contract), [Error Boundaries](/records/architecture/error-boundaries)", "term": "Refactored by" }, { "description": "a typed error contract held by the type checker, lint rules against thrown strings", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function a() { return null; }\nfunction b() { throw \"bad\"; }\nfunction c() { return { error: true }; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function a(): Result {}\nfunction b(): Result {}\nfunction c(): Result {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a typed error contract held by the type checker, lint rules against thrown strings", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Inconsistent Error Model](/records/architecture/inconsistent-error-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-inconsistent-error-model", "title": "Inconsistent Error Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which exceptions carry expected branching or normal absence.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Use exceptions for expected branching, normal absence, validation alternatives, or loop control.", "term": "Formed by" }, { "description": "try_catch_for_lookup_absence, exceptions_in_hot_loop, catch_chooses_normal_path", "term": "Detected by" }, { "description": "catch blocks on expected-absence paths", "term": "Measured by" }, { "description": "[Introduce Typed Result](/records/lexicon/introduce-typed-result), [Precondition Check](/records/lexicon/precondition-check)", "term": "Refactored by" }, { "description": "lint rules against catch blocks that choose the normal path", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "try {\n return await fooStore.find(id);\n} catch (notFound) {\n return fooStore.create(id);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await fooStore.find(id);\nreturn foo ?? fooStore.create(id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules against catch blocks that choose the normal path", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Exception Control Flow](/records/architecture/exception-control-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-exception-control-flow", "title": "Exception Control Flow" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [semantic_consistency](/records/force/semantic-consistency)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which null, empty, zero and missing are used interchangeably for one field.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Use null, undefined, empty string, zero, false, missing field, and empty collection interchangeably.", "term": "Formed by" }, { "description": "null_and_empty_string_same_field, optional_field_without_semantics, truthy_checks_for_domain_state", "term": "Detected by" }, { "description": "fields with more than one representation of absence", "term": "Measured by" }, { "description": "[Define Absence Semantics](/records/lexicon/define-absence-semantics), [Introduce Typed Result](/records/lexicon/introduce-typed-result), [Canonicalization](/records/architecture/canonicalization)", "term": "Refactored by" }, { "description": "schema nullability rules, strict null checking", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = find(id);\nif (foo) use(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = find(id) ?? Foo.none();\nfoo.use();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema nullability rules, strict null checking", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-null-semantics-drift", "title": "Null Semantics Drift" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "Aliases: Anemic Model", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which domain objects hold data only, while their rules live in services and handlers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Domain Model](/records/architecture/domain-model), [Aggregate](/records/architecture/aggregate), [Entity](/records/architecture/entity)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Store domain data in passive objects while business rules live in services, controllers, handlers, or scripts.", "term": "Formed by" }, { "description": "entities_with_getters_setters_only, services_contain_all_rules, validation_outside_aggregate", "term": "Detected by" }, { "description": "domain types without behavior, rules outside their aggregate", "term": "Measured by" }, { "description": "[Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Value Object](/records/architecture/value-object), [Add Aggregate Invariant](/records/lexicon/add-aggregate-invariant), [Encapsulate State](/records/lexicon/encapsulate-state)", "term": "Refactored by" }, { "description": "architecture tests that locate domain rules, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class Foo { status: string; }\nfunction shipFoo(foo: Foo) { if (foo.status === \"ready\") foo.status = \"shipped\"; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {\n private status = FooStatus.Ready;\n ship() { if (this.status !== FooStatus.Ready) throw new NotReadyError(); this.status = FooStatus.Shipped; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests that locate domain rules, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-anemic-domain-model", "title": "Anemic Domain Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary), [control_coordination](/records/force/control-coordination)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which business processes are procedural scripts that coordinate validation, persistence and decisions directly.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Domain Service](/records/architecture/domain-service)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Encode business processes as procedural scripts that directly coordinate validation, persistence, external calls, and domain decisions.", "term": "Formed by" }, { "description": "large_service_method, business_rules_in_controller, repeated_procedure_blocks", "term": "Detected by" }, { "description": "procedure length, business rules in handlers", "term": "Measured by" }, { "description": "[Extract Domain Model](/records/lexicon/extract-domain-model), [Extract Use Case](/records/lexicon/extract-use-case), [Introduce Port](/records/lexicon/introduce-port), [Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain)", "term": "Refactored by" }, { "description": "architecture tests on layer responsibilities, method size limits", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFooHandler(req) {\n validate(req); price(req); tax(req); persist(req); notify(req);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class CreateFoo {\n constructor(private readonly foos: FooRepository) {}\n execute(input: CreateFooInput) { const foo = Foo.create(input); return this.foos.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests on layer responsibilities, method size limits", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Transaction Script Sprawl](/records/architecture/transaction-script-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-transaction-script-sprawl", "title": "Transaction Script Sprawl" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [control_coordination](/records/force/control-coordination)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which controllers hold validation, business rules, persistence and response formatting.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Domain Service](/records/architecture/domain-service)", "term": "Referenced by" }, { "description": "[Transaction Script Sprawl](/records/architecture/transaction-script-sprawl): A fat controller puts business logic in the request handler, while transaction script sprawl writes business processes as procedural scripts wherever they live.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Put validation, business rules, persistence orchestration, mapping, authorization, and response formatting in the controller layer.", "term": "Formed by" }, { "description": "controller_method_too_large, repository_calls_plus_business_rules, domain_logic_in_route_handler", "term": "Detected by" }, { "description": "controller method size, repository calls from controllers", "term": "Measured by" }, { "description": "[Extract Use Case](/records/lexicon/extract-use-case), [Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Map to Domain Model](/records/lexicon/map-to-domain-model)", "term": "Refactored by" }, { "description": "layer rules that keep domain logic out of controllers, size limits", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooController {\n create(req) { const foo = { ...req.body }; if (!foo.name) throw 0; db.insert(foo); email(foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooController {\n constructor(private readonly createFoo: CreateFoo) {}\n create(req: Request) { return this.createFoo.execute(req.body); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "layer rules that keep domain logic out of controllers, size limits", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Fat Controller](/records/architecture/fat-controller)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fat-controller", "title": "Fat Controller" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary), [control_coordination](/records/force/control-coordination)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a repository accumulates business queries, policy and orchestration until it is a second service layer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Place business-specific querying, orchestration, mapping, caching, validation, and policy into a repository until it becomes a second service layer.", "term": "Formed by" }, { "description": "repository_methods_encode_business_process, authorization_in_repository, repository_calls_external_services", "term": "Detected by" }, { "description": "business-specific methods per repository", "term": "Measured by" }, { "description": "[Extract Query Service](/records/lexicon/extract-query-service), [Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Split Repository](/records/lexicon/split-repository), [Introduce Port](/records/lexicon/introduce-port)", "term": "Refactored by" }, { "description": "persistence-boundary rules, [design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooRepository { findActiveFoosForBarInRegionSortedByBaz() {} }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooRepository { find(spec: FooSpecification): Foo[] { return this.query(spec.toQuery()); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "persistence-boundary rules, design review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Repository Dump](/records/architecture/repository-dump)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-repository-dump", "title": "Repository Dump" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [domain_boundary](/records/force/domain-boundary)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which unrelated helpers accumulate in a generic utility module that no one owns.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[High Cohesion](/records/architecture/high-cohesion)", "term": "Referenced by" }, { "description": "[Shotgun Surgery](/records/architecture/shotgun-surgery): A utility dump gathers unrelated helpers in one module, while shotgun surgery spreads one responsibility across many files.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Accumulate unrelated helper functions in generic utility modules without ownership, cohesion, or domain language.", "term": "Formed by" }, { "description": "utils_file_growth, unrelated_helpers, many_modules_import_same_dump, generic_names", "term": "Detected by" }, { "description": "unrelated functions per utility module, importers per utility module", "term": "Measured by" }, { "description": "[Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Split by Domain](/records/lexicon/split-by-domain), [Value Object](/records/architecture/value-object), [Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "naming rules that reject catch-all module names, cohesion analysis", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "export function formatFoo() {}\nexport function parseBar() {}\nexport function hashBaz() {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const fooFormatter = { format(foo: Foo): string {} };\nexport const barParser = { parse(raw: string): Bar {} };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming rules that reject catch-all module names, cohesion analysis", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Utility Dump](/records/architecture/utility-dump)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-utility-dump", "title": "Utility Dump" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [domain_boundary](/records/force/domain-boundary)", "Aliases: Infrastructure-Centric Design, Framework-Centric Core", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which framework or infrastructure types, annotations or lifecycles enter core domain logic, so business rules depend on technical specifics.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Let framework classes, decorators, lifecycle assumptions, request objects, ORM entities, or infrastructure annotations enter core domain logic.", "term": "Formed by" }, { "description": "request_object_in_domain, ORM_entity_as_domain, framework_annotation_in_core, container_lookup_in_business_logic", "term": "Detected by" }, { "description": "framework imports in core modules", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Map to Domain Model](/records/lexicon/map-to-domain-model), [Introduce Port](/records/lexicon/introduce-port), [Move Framework Outward](/records/lexicon/move-framework-outward)", "term": "Refactored by" }, { "description": "import rules that keep framework packages out of the core", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class Foo { @Column() name: string; @OneToMany() bars: Bar[]; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo { constructor(readonly name: string, readonly bars: readonly Bar[]) {} }\nclass FooEntity { @Column() name: string; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules that keep framework packages out of the core", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Framework Leakage](/records/architecture/framework-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-framework-leakage", "title": "Framework Leakage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "Aliases: Shared Model Coupling", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an external system's or a vendor's APIs, errors and models spread through application and domain code, so their changes ripple across it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Spread vendor-specific APIs, models, exceptions, identifiers, or configuration throughout application and domain code.", "term": "Formed by" }, { "description": "vendor_imports_outside_adapter, vendor_error_types_in_domain, vendor_schema_as_canonical_model", "term": "Detected by" }, { "description": "vendor imports outside adapters", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Introduce Port](/records/lexicon/introduce-port), [Translate Errors at the Boundary](/records/lexicon/translate-errors-at-the-boundary), [Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Refactored by" }, { "description": "import rules that confine vendor packages to adapters", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "import { BlobStore } from \"acme-blob-sdk\";\nfunction saveFoo(foo) { return new BlobStore().putObject(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooBlobStore { put(foo: Foo): Promise; }\nfunction saveFoo(foo: Foo, store: FooBlobStore) { return store.put(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules that confine vendor packages to adapters", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-vendor-lock-in-leakage", "title": "Vendor Lock-In Leakage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Aliases: Cyclic Dependencies", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which modules depend on each other, directly or through others, so none can change alone.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph), [Low Coupling](/records/architecture/low-coupling)", "term": "Referenced by" }, { "description": "[Inappropriate Intimacy](/records/architecture/inappropriate-intimacy): A circular dependency is a cycle in the dependency graph, while inappropriate intimacy is a dependency on another module's internals, with or without a cycle.", "term": "Distinct from" }, { "description": "[Message Chain](/records/architecture/message-chain): A circular dependency is a cycle between modules, while a message chain is a client walking a chain of objects.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow modules to depend on each other directly or indirectly until no module can change, test, deploy, or initialize independently.", "term": "Formed by" }, { "description": "dependency_cycle, mutual_imports, bootstrap_order_hacks, bidirectional_service_calls", "term": "Detected by" }, { "description": "dependency cycles and their length", "term": "Measured by" }, { "description": "[Invert Dependency](/records/lexicon/invert-dependency), [Extract Interface](/records/lexicon/extract-interface), [Split Interface](/records/lexicon/split-interface), [Domain Events](/records/architecture/domain-events), [Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Refactored by" }, { "description": "a dependency-cycle check in the build", "term": "Enforced by" }, { "description": "circular-dependency", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "import { bar } from \"./bar\";\nexport const foo = () => bar();\nimport { foo } from \"./foo\";\nexport const bar = () => foo();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const foo = (run: () => void) => run();\nexport const bar = () => {};\nfoo(bar);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a dependency-cycle check in the build", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Circular Dependency](/records/architecture/circular-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-circular-dependency", "title": "Circular Dependency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which services must deploy in lockstep because each depends on the other's current version.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Require two or more services or packages to deploy in lockstep because each depends on the other’s current behavior.", "term": "Formed by" }, { "description": "coordinated_release_required, consumer_breaks_without_provider_release, mutual_contract_change", "term": "Detected by" }, { "description": "releases that required coordinated deployment", "term": "Measured by" }, { "description": "[Versioning](/records/architecture/versioning), [Backward-Compatible Change](/records/lexicon/backward-compatible-change), [Consumer-Driven Contract Tests](/records/lexicon/consumer-driven-contract-tests), [Compatibility Adapter](/records/lexicon/compatibility-adapter)", "term": "Refactored by" }, { "description": "[consumer-driven contract tests](/records/lexicon/consumer-driven-contract-tests), independent-deployment checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooService.callsAtStartup(barService);\nbarService.callsAtStartup(fooService);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooService.publishes(fooReady);\nbarService.subscribes(fooReady);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "consumer-driven contract tests, independent-deployment checks", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-cyclic-deployment-dependency", "title": "Cyclic Deployment Dependency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity)", "Aliases: Blocking Synchronous Chains", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one request depends on a deep chain of blocking synchronous remote calls, so one slow link stalls the whole request.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Asynchronous Communication](/records/architecture/asynchronous-communication)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Build deep request-time chains across services or modules, making latency, availability, and failure behavior multiplicative.", "term": "Formed by" }, { "description": "sync_depth_above_threshold, request_path_many_remote_calls, cascading_timeout", "term": "Detected by" }, { "description": "synchronous call depth per request path", "term": "Measured by" }, { "description": "[Coarse-Grained Endpoint](/records/lexicon/coarse-grained-endpoint), [Introduce Async Event](/records/lexicon/introduce-async-event), [Query Projection](/records/lexicon/query-projection), [Timeout Pattern](/records/architecture/timeout-pattern), [Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Refactored by" }, { "description": "call-depth limits in architecture review, timeout and bulkhead policies", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await a();\nconst bar = await b(foo);\nconst baz = await c(bar);\nreturn slowSyncCall(a, b, c);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const [foo, bar, baz] = await Promise.all([a(), b(), c()]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "call-depth limits in architecture review, timeout and bulkhead policies", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-synchronous-chain-trap", "title": "Synchronous Chain Trap" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one operation needs many small remote calls.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Require many small remote calls to complete one user or business operation.", "term": "Formed by" }, { "description": "N_plus_1_API_calls, many_calls_per_screen, loop_contains_remote_call", "term": "Detected by" }, { "description": "remote calls per user operation", "term": "Measured by" }, { "description": "[Coarse-Grained Endpoint](/records/lexicon/coarse-grained-endpoint), [Query Projection](/records/lexicon/query-projection), [Batch Fetch](/records/lexicon/batch-fetch)", "term": "Refactored by" }, { "description": "API review, performance tests that bound call counts", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const results = [];\nfor (const id of fooIds) results.push(await fooApi.get(id));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const results = await fooApi.getMany(fooIds);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API review, performance tests that bound call counts", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Chatty Interface](/records/architecture/chatty-interface)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-chatty-interface", "title": "Chatty Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: N+1 Query", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a collection is fetched and then one further query is issued per item.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Fetch a collection, then issue one query or remote call per item rather than fetching required related data intentionally.", "term": "Formed by" }, { "description": "query_inside_loop, remote_call_inside_loop, query_count_scales_with_rows", "term": "Detected by" }, { "description": "queries per request as the row count grows", "term": "Measured by" }, { "description": "[Batch Fetch](/records/lexicon/batch-fetch), [Query Projection](/records/lexicon/query-projection)", "term": "Refactored by" }, { "description": "query-count assertions in integration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foos = await fooStore.all();\nfor (const foo of foos) foo.bar = await barStore.find(foo.barId);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foos = await fooStore.all();\nconst bars = await barStore.findMany(foos.map(f => f.barId));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "query-count assertions in integration tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[N Plus One Query](/records/architecture/n-plus-one-query)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-n-plus-one-query", "title": "N Plus One Query" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a cache key omits an input the entry depends on, so one request is served another's result.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Caching](/records/architecture/caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Cache data without key correctness, tenant isolation, authorization context, invalidation, or schema version, or key the entry by time or lifetime alone.", "term": "Formed by" }, { "description": "cache_key_missing_user_or_tenant, cache_without_version, cache_keyed_by_time, no_invalidation, authorization_not_in_cache_key", "term": "Detected by" }, { "description": "cache keys missing tenant, identity or version", "term": "Measured by" }, { "description": "[Cache Contract](/records/lexicon/cache-contract), [Context-Keyed Cache](/records/lexicon/context-keyed-cache), [Cache Invalidation on Write](/records/lexicon/cache-invalidation-on-write), [Versioning](/records/architecture/versioning)", "term": "Refactored by" }, { "description": "cache-key review, tests that vary tenant and version", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooCache.set(request.path, response);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (response.ok && response.cacheable) {\n fooCache.set(cacheKey(request.identity, request.path, fingerprint(request.inputs, SCHEMA_VERSION)), response);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "cache-key review, tests that vary tenant and version", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-cache-poisoning-by-design", "title": "Cache Poisoning by Design" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [resilience_recovery](/records/force/resilience-recovery)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which clients retry a failing dependency so aggressively that the retries prolong the failure.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow many clients or workers to retry failed dependencies aggressively and synchronously, increasing pressure on the failing system.", "term": "Formed by" }, { "description": "no_backoff, no_jitter, unbounded_retries, retry_on_non_idempotent_operation", "term": "Detected by" }, { "description": "retries per failed call, retry share of load during incidents", "term": "Measured by" }, { "description": "[Bounded Retry](/records/lexicon/bounded-retry), [Backoff](/records/lexicon/backoff), [Jitter](/records/lexicon/jitter), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern), [Idempotency Key](/records/lexicon/idempotency-key)", "term": "Refactored by" }, { "description": "a resilience policy that requires bounded retries with backoff and jitter", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "while (true) { try { return await call(); } catch { } }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "return retry(call, { attempts: 5, backoff: exponentialJitter(), giveUp: dlq });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a resilience policy that requires bounded retries with backoff and jitter", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Retry Storm](/records/architecture/retry-storm)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-retry-storm", "title": "Retry Storm" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [resilience_recovery](/records/force/resilience-recovery)", "Aliases: Infinite Wait", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which calls to external systems carry no timeout, cancellation or deadline, so a caller can wait for ever on work that never completes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Call external systems without explicit timeouts, cancellation, or deadline propagation.", "term": "Formed by" }, { "description": "HTTP_call_without_timeout, DB_query_without_timeout, missing_cancellation_token, no_deadline_propagation", "term": "Detected by" }, { "description": "outbound calls without a timeout", "term": "Measured by" }, { "description": "[Timeout Pattern](/records/architecture/timeout-pattern), [Deadline Propagation](/records/lexicon/deadline-propagation), [Cancellation](/records/lexicon/cancellation), [Fail Fast or Fall Back](/records/lexicon/fail-fast-or-fall-back)", "term": "Refactored by" }, { "description": "a lint rule that requires a timeout on outbound calls", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await fetch(fooUrl);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await fetch(fooUrl, { signal: AbortSignal.timeout(5000) });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule that requires a timeout on outbound calls", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Timeout Omission](/records/architecture/timeout-omission)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-timeout-omission", "title": "Timeout Omission" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [resilience_recovery](/records/force/resilience-recovery)", "Aliases: Unbounded Ingestion", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a system accepts work faster than it can process it, with no limit or shedding.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Accept work faster than the system can process it without queue limits, admission control, rate limits, or shedding.", "term": "Formed by" }, { "description": "unbounded_queue, no_rate_limit, no_admission_control, memory_grows_with_load", "term": "Detected by" }, { "description": "queue depth and memory growth under load", "term": "Measured by" }, { "description": "[Bounded Queue](/records/lexicon/bounded-queue), [Rate Limiting](/records/architecture/rate-limiting), [Load Shedding](/records/lexicon/load-shedding), [Backpressure](/records/architecture/backpressure)", "term": "Refactored by" }, { "description": "load tests, checks that every queue is configured with a bound", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "stream.on(\"data\", d => queue.push(process(d)));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "stream.pipe(new BoundedFooProcessor({ highWaterMark: 100 }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "load tests, checks that every queue is configured with a bound", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-missing-backpressure", "title": "Missing Backpressure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which invalid data is accepted, transformed or stored without any check noticing.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Fail Fast](/records/architecture/fail-fast)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Accept, transform, or persist invalid data without validation, checksums, invariants, reconciliation, or audit.", "term": "Formed by" }, { "description": "missing_boundary_validation, no_invariant_check, impossible_state_in_database, reconciliation_failures", "term": "Detected by" }, { "description": "invariant violations and reconciliation mismatches", "term": "Measured by" }, { "description": "[Validate at the Boundary](/records/lexicon/validate-at-the-boundary), [Invariant Check](/records/lexicon/invariant-check), [Reconciliation Job](/records/lexicon/reconciliation-job), [Data Change Audit](/records/lexicon/data-change-audit)", "term": "Refactored by" }, { "description": "boundary validation, invariant checks, reconciliation jobs", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const total = Number(a) + Number(b);\nsave(total);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const total = Money.add(Money.parse(a), Money.parse(b));\nsave(total);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "boundary validation, invariant checks, reconciliation jobs", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-silent-data-corruption", "title": "Silent Data Corruption" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [state_transaction](/records/force/state-transaction)", "Aliases: Whole-File Write Race", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which concurrent writers overwrite each other's changes without a version check.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Write Barrier](/records/architecture/write-barrier), [Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Allow concurrent writers to overwrite each other without version checks, locks, compare-and-swap, or transaction isolation.", "term": "Formed by" }, { "description": "last_write_wins_without_version, no_optimistic_lock, concurrent_update_defects", "term": "Detected by" }, { "description": "concurrent update conflicts found in tests", "term": "Measured by" }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking), [Pessimistic Locking](/records/architecture/pessimistic-locking), [Merge Policy](/records/lexicon/merge-policy), [Transaction Isolation Level](/records/lexicon/transaction-isolation-level)", "term": "Refactored by" }, { "description": "optimistic-locking checks, concurrency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await load(id);\nfoo.count += 1;\nawait save(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await fooStore.update(id, { count: increment(1) }, { expectedVersion: foo.version });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "optimistic-locking checks, concurrency tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-lost-update", "title": "Lost Update" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [event_messaging](/records/force/event-messaging)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which related state is written to two systems with no atomicity or compensation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Write related state to two systems without atomicity, outbox, saga, reconciliation, or compensation.", "term": "Formed by" }, { "description": "database_write_then_message_publish, two_databases_updated_without_transaction_or_outbox, manual_repair_needed", "term": "Detected by" }, { "description": "writes to two systems outside one transaction or outbox", "term": "Measured by" }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern), [Saga Pattern](/records/architecture/saga-pattern), [Idempotent Consumer](/records/architecture/idempotent-consumer), [Reconciliation Job](/records/lexicon/reconciliation-job)", "term": "Refactored by" }, { "description": "an outbox or saga, verified by integration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await db.save(foo);\nawait searchIndex.add(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await db.save(foo);\nawait outbox.append(fooCreatedEvent(foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "an outbox or saga, verified by integration tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Dual Write](/records/architecture/dual-write)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dual-write", "title": "Dual Write" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a writer reads back a stale copy of what it has just written.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Let users or processes perform a write and then read from a stale replica, cache, projection, or eventually consistent view without explicit consistency contract.", "term": "Formed by" }, { "description": "write_then_stale_read_defect, cache_not_invalidated_after_write, replica_read_after_write", "term": "Detected by" }, { "description": "stale reads observed after writes", "term": "Measured by" }, { "description": "[Read From Primary After Write](/records/lexicon/read-from-primary-after-write), [Cache Invalidation on Write](/records/lexicon/cache-invalidation-on-write), [Consistency Contract](/records/lexicon/consistency-contract)", "term": "Refactored by" }, { "description": "consistency-contract tests that read after a write", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await primaryDb.write(foo);\nconst view = await replicaDb.read(foo.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await primaryDb.write(foo);\nconst view = await readAfterWrite(foo.id, { consistency: \"read-your-writes\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "consistency-contract tests that read after a write", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Read-Your-Writes Violation](/records/architecture/read-your-writes-violation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-read-your-writes-violation", "title": "Read-Your-Writes Violation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which visible security controls leave the real threat unreduced, or can be bypassed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Add visible security controls that do not reduce the actual threat model or can be bypassed by alternate paths.", "term": "Formed by" }, { "description": "control_not_linked_to_threat, bypass_endpoint, client_only_security, audit_passes_but_attack_succeeds", "term": "Detected by" }, { "description": "controls not linked to a threat, bypass paths found", "term": "Measured by" }, { "description": "[Threat Modeling](/records/architecture/threat-modeling), [Server-Side Enforcement](/records/lexicon/server-side-enforcement), [Penetration Testing](/records/lexicon/penetration-testing), [Policy as Code](/records/architecture/policy-as-code)", "term": "Refactored by" }, { "description": "threat-model review, penetration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (password.length > 0) grantFooAccess(user);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const verified = await verifyPassword(password, user.passwordHash);\nif (!verified) throw new UnauthorizedError();\ngrantFooAccess(user);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "threat-model review, penetration tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Security Theater](/records/architecture/security-theater)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-security-theater", "title": "Security Theater" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which authorization checks are spread across layers with no central policy.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Authorization](/records/architecture/authorization)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Spread authorization checks across controllers, services, repositories, UI, and ad hoc conditionals without a central policy model.", "term": "Formed by" }, { "description": "repeated_role_checks, missing_policy_engine, endpoint_without_authz, inconsistent_resource_access", "term": "Detected by" }, { "description": "endpoints without a policy check, duplicated role checks", "term": "Measured by" }, { "description": "[Centralize Policy](/records/lexicon/centralize-policy), [Policy as Code](/records/architecture/policy-as-code), [Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control), [Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control), [Authorization Tests](/records/lexicon/authorization-tests)", "term": "Refactored by" }, { "description": "a policy engine, with authorization tests per endpoint", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (user.role === \"admin\") deleteFoo();\nif (user.role === \"admin\" || user.id === foo.owner) editFoo();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (policy.can(user, \"delete\", foo)) deleteFoo();\nif (policy.can(user, \"edit\", foo)) editFoo();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a policy engine, with authorization tests per endpoint", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Authorization Scattering](/records/architecture/authorization-scattering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-authorization-scattering", "title": "Authorization Scattering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [modularity](/records/force/modularity), [security_governance](/records/force/security-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which credentials and keys are stored across code, logs and configuration.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Store credentials, tokens, keys, certificates, or sensitive configuration across code, config files, logs, tickets, and local environments.", "term": "Formed by" }, { "description": "secret_in_repo, secret_in_log, shared_static_token, manual_secret_distribution", "term": "Detected by" }, { "description": "secrets found in source and logs", "term": "Measured by" }, { "description": "[Secrets Management](/records/architecture/secrets-management), [Secret Rotation](/records/lexicon/secret-rotation), [Repository Secret Scan](/records/lexicon/repository-secret-scan), [Least-Privilege Credential](/records/lexicon/least-privilege-credential)", "term": "Refactored by" }, { "description": "secret scanning in the build, a secret store", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const key = \"sk_live_abc123\";\nconst dbPass = \"hunter2\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const key = await secrets.get(\"foo.api.key\");\nconst dbPass = await secrets.get(\"foo.db.password\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "secret scanning in the build, a secret store", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Secret Sprawl](/records/architecture/secret-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-secret-sprawl", "title": "Secret Sprawl" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [architecture_evolution](/records/force/architecture-evolution)", "Aliases: Unbounded Data Collection", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which more personal data is collected, kept, logged or exposed than the declared purpose needs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Collect, store, log, transmit, or expose more personal data than needed for the declared purpose.", "term": "Formed by" }, { "description": "personal_data_in_logs, unused_sensitive_fields, broad_export, missing_data_minimization", "term": "Detected by" }, { "description": "personal-data fields in logs and exports", "term": "Measured by" }, { "description": "[Purpose Binding](/records/lexicon/purpose-binding), [Field Redaction](/records/lexicon/field-redaction), [Retention Policy](/records/lexicon/retention-policy)", "term": "Refactored by" }, { "description": "privacy review, log redaction rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "logger.info(\"created foo\", { email: user.email, ssn: user.ssn });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "logger.info(\"created foo\", { userId: user.id });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "privacy review, log redaction rules", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-personal-data-oversharing", "title": "Personal Data Oversharing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [observability_traceability](/records/force/observability-traceability)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which logs, metrics and alerts are too many and too low in signal to act on.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Alerting](/records/architecture/alerting)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Emit excessive, low-signal logs, metrics, traces, or alerts without severity, ownership, cardinality control, or actionability.", "term": "Formed by" }, { "description": "high_alert_ack_without_action, high_cardinality_metrics, logs_without_context, duplicate_alerts", "term": "Detected by" }, { "description": "alerts acknowledged without action, high-cardinality metrics", "term": "Measured by" }, { "description": "[Define Signal Quality](/records/lexicon/define-signal-quality), [Cardinality Reduction](/records/lexicon/cardinality-reduction), [Runbook Owner](/records/lexicon/runbook-owner), [Sampling and Aggregation](/records/lexicon/sampling-and-aggregation)", "term": "Refactored by" }, { "description": "alert-ownership rules, metric cardinality limits", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "logger.info(\"entering loop\");\nfor (const f of foos) logger.info(\"iter\", f);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "logger.info(\"foo.batch.processed\", { count: foos.length, durationMs });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "alert-ownership rules, metric cardinality limits", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Observability Noise](/records/architecture/observability-noise)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-observability-noise", "title": "Observability Noise" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a failure is logged as though logging handled it, and execution continues.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Logging](/records/architecture/logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Log errors or warnings as if logging itself handles the failure, while the system continues without recovery, propagation, or safe fallback.", "term": "Formed by" }, { "description": "catch_log_continue, logged_error_without_return_or_throw, critical_log_no_alert", "term": "Detected by" }, { "description": "catch blocks that log and continue", "term": "Measured by" }, { "description": "[Introduce Typed Result](/records/lexicon/introduce-typed-result), [Fail Fast or Fall Back](/records/lexicon/fail-fast-or-fall-back), [Recovery Policy](/records/lexicon/recovery-policy), [Alert on Critical Failure](/records/lexicon/alert-on-critical-failure)", "term": "Refactored by" }, { "description": "a lint rule against catch blocks that only log", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "try { await chargeFoo(foo); } catch (error) { logger.error(\"foo.charge.failed\", error); }\nshipFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const outcome = await chargeFoo(foo);\nif (!outcome.ok) throw new ChargeFailedError(foo.id, outcome.error);\nshipFoo(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a lint rule against catch blocks that only log", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Log-as-Control-Flow](/records/architecture/log-as-control-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-log-as-control-flow", "title": "Log-as-Control-Flow" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [resilience_recovery](/records/force/resilience-recovery)", "Aliases: Manual-Only Recovery, Manual Intervention Dependency", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which repeatable operational steps, such as detecting a failure and recovering from it, are performed by hand during incidents and deploys, so recovery waits on a person.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture), [Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Perform by hand the repeatable operational actions during incidents, deploys, migrations, or recovery.", "term": "Formed by" }, { "description": "same_manual_incident_steps, manual_migration_sequence, operator_specific_knowledge", "term": "Detected by" }, { "description": "manual steps repeated across incidents", "term": "Measured by" }, { "description": "[Automate the Runbook](/records/lexicon/automate-the-runbook), [Guardrails](/records/lexicon/guardrails), [Precondition Check](/records/lexicon/precondition-check), [Execution Log](/records/lexicon/execution-log)", "term": "Refactored by" }, { "description": "operations review of manual steps repeated across incidents", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const RUNBOOK = \"on failure, ssh in and run restart-foo.sh\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "health.onUnhealthy(() => orchestrator.restart(\"foo\"));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "operations review of manual steps repeated across incidents", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-manual-runbook-dependency", "title": "Manual Runbook Dependency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [state_transaction](/records/force/state-transaction)", "Aliases: Big-Bang Deployment", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a large, irreversible change reaches every user at once, with no staged rollout.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Ship a large, irreversible, all-user change without staged rollout, feature flags, canary, rollback, or blast-radius control.", "term": "Formed by" }, { "description": "no_canary, no_feature_flag, no_rollback_plan, large_release_batch", "term": "Detected by" }, { "description": "release batch size, releases without a rollback path", "term": "Measured by" }, { "description": "[Feature Toggle](/records/architecture/feature-toggle), [Canary Deployment](/records/architecture/canary-deployment), [Blue-Green Deployment](/records/architecture/blue-green-deployment), [Rollback Plan](/records/lexicon/rollback-plan), [Small-Batch Release](/records/lexicon/small-batch-release)", "term": "Refactored by" }, { "description": "release gates that require a canary or a feature flag and a rollback plan", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployEverything(\"foo\", \"bar\", \"baz\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "release(\"foo\", { strategy: canary(0.1) });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "release gates that require a canary or a feature flag and a rollback plan", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Big-Bang Release](/records/architecture/big-bang-release)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-big-bang-release", "title": "Big-Bang Release" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [architecture_evolution](/records/force/architecture-evolution)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a schema or data change can neither run beside the old version nor be rolled back.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Apply schema, data, or infrastructure changes that cannot safely run alongside old versions or be rolled back.", "term": "Formed by" }, { "description": "drop_column_before_consumers_removed, destructive_data_transform_no_backup, no_backward_compatible_phase", "term": "Detected by" }, { "description": "migrations without a down step or a compatible phase", "term": "Measured by" }, { "description": "[Expand-Contract Migration](/records/lexicon/expand-contract-migration), [Backup](/records/lexicon/backup), [Dual Read and Write](/records/lexicon/dual-read-and-write), [Rollback Plan](/records/lexicon/rollback-plan)", "term": "Refactored by" }, { "description": "migration review, rollback tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await db.exec(\"ALTER TABLE foo DROP COLUMN legacy_name\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await migrate({ up: addFooName, down: restoreFooName });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "migration review, rollback tests", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Irreversible Migration](/records/architecture/irreversible-migration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-irreversible-migration", "title": "Irreversible Migration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [domain_boundary](/records/force/domain-boundary)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which major architectural decisions are fixed before the forces they answer are known.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" }, { "description": "[Lava Flow](/records/architecture/lava-flow): Frozen architecture fixes decisions too early, while lava flow keeps obsolete code too long.", "term": "Distinct from" }, { "description": "[Premature Abstraction](/records/architecture/premature-abstraction): Frozen architecture fixes system-level decisions early, while premature abstraction extracts one shared abstraction early.", "term": "Distinct from" }, { "description": "[Zombie Code](/records/architecture/zombie-code): Frozen architecture is a decision made too early, while zombie code is dead code left behind.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Lock in major architectural decisions before validating domain forces, quality attributes, operational realities, and change vectors.", "term": "Formed by" }, { "description": "heavy_architecture_before_usage, ADR_without_evidence, future-proofing_without_feedback", "term": "Detected by" }, { "description": "decisions recorded without evidence", "term": "Measured by" }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture), [Evolutionary Architecture](/records/architecture/evolutionary-architecture), [Fitness Functions](/records/architecture/fitness-functions), [Decision Review](/records/lexicon/decision-review)", "term": "Refactored by" }, { "description": "decision records that require evidence, periodic decision review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const ARCHITECTURE = designAllModulesForNextFiveYears();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = defineModule(\"foo\", { exports: { createFoo } });\nregistry.add(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "decision records that require evidence, periodic decision review", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Big-Upfront Frozen Architecture](/records/architecture/big-upfront-frozen-architecture)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-big-upfront-frozen-architecture", "title": "Big-Upfront Frozen Architecture" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "Aliases: Over-Architecture", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which abstract frameworks, meta-models and architectural structure are built ahead of the concrete needs they should serve.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" }, { "description": "[Over-Abstraction](/records/architecture/over-abstraction): An astronaut builds frameworks for needs that have not arrived, while over-abstraction adds layers beyond the variation that exists.", "term": "Distinct from" }, { "description": "[Speculative Generality](/records/architecture/speculative-generality): An astronaut builds whole frameworks and meta-models, while speculative generality is one abstraction built for variation with no evidence of arriving.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "Prefer abstract frameworks, taxonomies, meta-models, and generic engines over concrete user, domain, and operational needs.", "term": "Formed by" }, { "description": "generic_platform_before_product_need, few_real_consumers, high_framework_workaround_count", "term": "Detected by" }, { "description": "generic components with few real consumers", "term": "Measured by" }, { "description": "[Anchor to Use Cases](/records/lexicon/anchor-to-use-cases), [Vertical Slice Proof](/records/lexicon/vertical-slice-proof), [Inline Abstraction](/records/lexicon/inline-abstraction), [Measure Delivery Cost](/records/lexicon/measure-delivery-cost)", "term": "Refactored by" }, { "description": "design review against real use cases", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class AbstractFooMetaStrategyOrchestrationEngineFactory {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class CreateFoo { execute(input: CreateFooInput): Foo {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review against real use cases", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-architecture-astronaut", "title": "Architecture Astronaut" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [security_governance](/records/force/security-governance), [performance_scaling](/records/force/performance-scaling)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which architecture serves immediate features while its quality attributes go unaddressed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Optimize architecture for immediate feature delivery while ignoring quality attributes such as security, operability, scalability, maintainability, and evolvability.", "term": "Formed by" }, { "description": "no_SLOs, no_security_review, no_operability_requirements, quality_attribute_absent_from_ADR", "term": "Detected by" }, { "description": "quality attributes absent from decisions, services without SLOs", "term": "Measured by" }, { "description": "[Quality Scenarios](/records/lexicon/quality-scenarios), [Fitness Functions](/records/architecture/fitness-functions), [Architecture Review](/records/architecture/architecture-review), [Risk Register](/records/lexicon/risk-register)", "term": "Refactored by" }, { "description": "architecture review with quality scenarios, SLO gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function addFooFeature() { hack(); patch(); bypassLint(); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function addFooFeature(input: CreateFooInput) { return createFoo.execute(input); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review with quality scenarios, SLO gates", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Feature-Only Design](/records/architecture/feature-only-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-feature-only-design", "title": "Feature-Only Design" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a test suite relies mainly on slow end-to-end tests, with few unit and contract tests.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Testability](/records/architecture/testability)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Rely mainly on slow, brittle end-to-end tests while unit, contract, component, and property tests are sparse.", "term": "Formed by" }, { "description": "high_E2E_ratio, slow_CI, flaky_integration_tests, low_unit_contract_coverage", "term": "Detected by" }, { "description": "share of end-to-end tests, suite duration", "term": "Measured by" }, { "description": "[Unit Tests](/records/lexicon/unit-tests), [Contract Testing](/records/lexicon/contract-testing), [Component Tests](/records/lexicon/component-tests), [Property-Based Testing](/records/architecture/property-based-testing)", "term": "Refactored by" }, { "description": "test-suite composition review, limits on CI duration", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "test.e2e(\"create foo\", fullBrowserFlow);\ntest.e2e(\"rename foo\", fullBrowserFlow);\ntest.e2e(\"delete foo\", fullBrowserFlow);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "test.unit(\"FooValidator rejects an empty name\", () => expect(() => validateFoo({ name: \"\" })).toThrow());\ntest.integration(\"FooRepository persists a Foo\", async () => {\n await fooRepository.save(foo);\n expect(await fooRepository.find(foo.id)).toEqual(foo);\n});\ntest.e2e(\"the critical signup path\", criticalPathOnly);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "test-suite composition review, limits on CI duration", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Test Pyramid Inversion](/records/architecture/test-pyramid-inversion)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-test-pyramid-inversion", "title": "Test Pyramid Inversion" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which tests assert calls on mocks rather than observable behavior or contracts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Overuse mocks so tests verify internal calls rather than observable behavior or contracts.", "term": "Formed by" }, { "description": "tests_fail_on_refactor_without_behavior_change, assert_called_everywhere, no_contract_tests", "term": "Detected by" }, { "description": "tests that break on refactors with no change in behavior", "term": "Measured by" }, { "description": "[Test Observable Behavior](/records/lexicon/test-observable-behavior), [Contract Testing](/records/lexicon/contract-testing), [Fake at the Boundary](/records/lexicon/fake-at-the-boundary)", "term": "Refactored by" }, { "description": "contract tests, review of mock usage", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const store = { save: fn(), find: fn().returns(foo) };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const store = new InMemoryFooStore();\nrunFooStoreContract(store);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, review of mock usage", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Mock Mirage](/records/architecture/mock-mirage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-mock-mirage", "title": "Mock Mirage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which intermittent test failures are accepted and rerun until they pass.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Accept intermittent test failures as normal and rerun until green instead of fixing nondeterminism or isolation defects.", "term": "Formed by" }, { "description": "rerun_to_pass, quarantined_tests_never_fixed, time_order_random_test_failures", "term": "Detected by" }, { "description": "rerun rate, quarantined tests past their fix date", "term": "Measured by" }, { "description": "[Isolate Test State](/records/lexicon/isolate-test-state), [Inject Clock and Randomness](/records/lexicon/inject-clock-and-randomness), [Fix the Race](/records/lexicon/fix-the-race), [Fake at the Boundary](/records/lexicon/fake-at-the-boundary)", "term": "Refactored by" }, { "description": "a CI policy that fails on a retried test and tracks every quarantined one", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "test.retry(5)(\"foo works sometimes\", async () => { await sleep(random()); expect(await getFoo()).toBeTruthy(); });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "test(\"foo is created deterministically\", async () => { const foo = await createFoo.execute(input); expect(foo.id).toBe(expectedId); });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a CI policy that fails on a retried test and tracks every quarantined one", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-flaky-test-normalization", "title": "Flaky Test Normalization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [contract_compatibility](/records/force/contract-compatibility), [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which prompts, model parameters and output schemas are scattered through code without versions or evaluation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Prompt Engineering](/records/architecture/prompt-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Scatter prompts, retrieval rules, model parameters, safety instructions, and output schemas across code without versioning, evaluation, or ownership.", "term": "Formed by" }, { "description": "prompt_literals_in_many_files, no_prompt_registry, no_eval_for_prompt_change, model_params_scattered", "term": "Detected by" }, { "description": "prompt literals outside the registry", "term": "Measured by" }, { "description": "[Prompt Registry](/records/lexicon/prompt-registry), [Prompt Versioning](/records/lexicon/prompt-versioning), [Evaluation Suite](/records/lexicon/evaluation-suite), [Centralized Model Configuration](/records/lexicon/centralized-model-configuration)", "term": "Refactored by" }, { "description": "a prompt registry, with an evaluation required on every change", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const a = model.run(\"summarize this foo: \" + foo);\nconst b = model.run(\"pls summarize foo \" + foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const summary = model.run(FOO_PROMPTS.summarize({ foo }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a prompt registry, with an evaluation required on every change", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-prompt-sprawl", "title": "Prompt Sprawl" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which the model produces answers or decisions without retrieved evidence or disclosed uncertainty.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "Generate answers, classifications, plans, or decisions without evidence retrieval, source references, confidence limits, or unsupported-claim handling.", "term": "Formed by" }, { "description": "answer_without_sources_when_sources_required, no_retrieval_trace, unsupported_claims, confidence_not_disclosed", "term": "Detected by" }, { "description": "answers without a source where one is required", "term": "Measured by" }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation), [Evidence Citation](/records/lexicon/evidence-citation), [Claim Validation](/records/lexicon/claim-validation), [Abstain or Disclose Uncertainty](/records/lexicon/abstain-or-disclose-uncertainty)", "term": "Refactored by" }, { "description": "retrieval evaluation, claim validation against the retrieved sources", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const answer = await model.run(question);\nreturn answer;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const context = await retrieve(question);\nconst answer = await model.run(FOO_PROMPTS.answer({ question, context }));\nreturn withCitations(answer, context);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "retrieval evaluation, claim validation against the retrieved sources", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-ungrounded-content", "title": "Ungrounded Content" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [anti-patterns](/records/architecture-category/anti-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [model_governance](/records/force/model-governance)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which models, prompts or indexes are used without recording their version and configuration.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "Use models, embeddings, prompts, or evaluation artifacts without recording version, configuration, dataset, or inference context.", "term": "Formed by" }, { "description": "model_name_missing_version, embedding_index_unversioned, eval_results_without_config, prompt_not_versioned", "term": "Detected by" }, { "description": "inferences logged without a model version", "term": "Measured by" }, { "description": "[Model Registry](/records/lexicon/model-registry), [Prompt Versioning](/records/lexicon/prompt-versioning), [Inference Context Record](/records/lexicon/inference-context-record), [Governance Log](/records/lexicon/governance-log)", "term": "Refactored by" }, { "description": "a model registry, inference logging that requires a version", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const result = await model.run(prompt);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const result = await model.run(prompt, { model: \"foo-llm-2024-06\", temperature: 0 });\nlogger.info(\"foo.inference\", { model: result.model });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a model registry, inference logging that requires a version", "term": "Checked by" }, { "description": "Every module, boundary and change the anti-pattern's detection signals scan", "term": "Population" }, { "description": "A verdict stands until the scanned code or the enforcing rule changes", "term": "Freshness" }, { "description": "The enforcing check fails the gate on a new instance, so a closed decay path cannot re-enter", "term": "Refusal" }, { "description": "The detection signals the record lists, read from source or from runtime telemetry as each signal requires", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The principle the anti-pattern conflicts with, which the enforcing check holds new code to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-version-ambiguity", "title": "Model Version Ambiguity" } ], "title": "Anti-patterns" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_domain_driven_design[\"Domain-Driven Design (DDD)\"]\n n_domain_model[\"Domain Model\"]\n n_bounded_context[\"Bounded Context\"]\n n_context_mapping[\"Context Mapping\"]\n n_anti_corruption_layer[\"Anti-Corruption Layer\"]\n n_explicit_boundaries[\"Explicit Boundaries\"]\n n_aggregate[\"Aggregate\"]\n n_value_object[\"Value Object\"]\n n_entity[\"Entity\"]\n n_domain_service[\"Domain Service\"]\n n_domain_driven_design --> n_bounded_context\n n_domain_driven_design --> n_domain_model\n n_bounded_context --> n_explicit_boundaries\n n_bounded_context --> n_context_mapping\n n_context_mapping --> n_bounded_context\n n_context_mapping --> n_explicit_boundaries\n n_context_mapping --> n_anti_corruption_layer\n n_aggregate --> n_explicit_boundaries\n n_entity --> n_domain_model\n n_entity -.-> n_value_object\n n_domain_service --> n_domain_model\n n_domain_service -.-> n_aggregate" } ], "icon": "bi-collection", "id": "architecture-category-domain-architecture", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, bounded context, system", "Aliases: DDD", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A convention of modeling software on the business domain's own language, split into bounded contexts with a domain model in each.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Bounded Context](/records/architecture/bounded-context)", "term": "Requires" }, { "description": "[Domain Model](/records/architecture/domain-model), [Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Reinforces" }, { "description": "[Domain Alignment](/records/lexicon/domain-alignment)", "term": "Enables" }, { "description": "[Simple CRUD](/records/lexicon/simple-crud)", "term": "In tension with" }, { "description": "[Anemic Transaction Script](/records/lexicon/anemic-transaction-script)", "term": "Conflicts with" }, { "description": "[Domain Events](/records/architecture/domain-events), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Referenced by" }, { "description": "[Domain-Driven Design (DDD) / Simple CRUD](/records/tension/domain-driven-design-ddd-simple-crud)", "term": "Tensions" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture): Domain-driven design models software on the domain's language, while event-driven architecture connects services through published events.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model), [Fat Controller](/records/architecture/fat-controller)", "term": "Violated by" }, { "description": "anemic models, scattered business rules", "term": "Detected by" }, { "description": "domain logic locality", "term": "Measured by" }, { "description": "[Extract Domain Model](/records/lexicon/extract-domain-model), [Aggregate](/records/architecture/aggregate), [Split Bounded Context](/records/lexicon/split-bounded-context)", "term": "Refactored by" }, { "description": "layer rules, domain tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function updateFoo(row: FooRow, name: string) {\n row.name = name;\n row.updated_at = Date.now();\n return fooTable.save(row);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {\n private constructor(readonly id: FooId, private name: string) {}\n rename(name: FooName) { this.name = name.value; }\n}\nfoo.rename(FooName.create(name));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "layer rules, domain tests", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Bounded Context](/records/architecture/bounded-context), [Domain Model](/records/architecture/domain-model), [Semantic Consistency](/records/architecture/semantic-consistency), [Domain Alignment](/records/lexicon/domain-alignment)", "term": "Depends on" }, { "description": "[Anemic Transaction Script](/records/lexicon/anemic-transaction-script)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-domain-driven-design", "title": "Domain-Driven Design (DDD)" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, bounded context", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the business concepts, rules and invariants of one context, written as types with behavior.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Invariant](/records/architecture/invariant)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Reinforces" }, { "description": "[Business Rule Encapsulation](/records/lexicon/business-rule-encapsulation)", "term": "Enables" }, { "description": "[Persistence Simplicity](/records/lexicon/persistence-simplicity)", "term": "In tension with" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Conflicts with" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Entity](/records/architecture/entity), [Domain Service](/records/architecture/domain-service), [Semantic Contracts](/records/architecture/semantic-contracts), [Domain Events](/records/architecture/domain-events)", "term": "Referenced by" }, { "description": "[Domain Model / Persistence Simplicity](/records/tension/domain-model-persistence-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Violated by" }, { "description": "procedural domain logic in services/controllers", "term": "Detected by" }, { "description": "rule locality, invariant coverage", "term": "Measured by" }, { "description": "[Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Value Object](/records/architecture/value-object), [Aggregate](/records/architecture/aggregate)", "term": "Refactored by" }, { "description": "domain layer rules, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type Foo = { status: string; count: number };\nfunction closeFoo(foo: Foo) { foo.status = \"closed\"; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {\n #status: \"open\" | \"closed\" = \"open\";\n close() {\n if (this.#status === \"closed\") throw new Error(\"Foo already closed\");\n this.#status = \"closed\";\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain layer rules, tests", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Invariant](/records/architecture/invariant), [Correctness](/records/architecture/correctness), [Semantic Contracts](/records/architecture/semantic-contracts), [Business Rule Encapsulation](/records/lexicon/business-rule-encapsulation)", "term": "Depends on" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-domain-model", "title": "Domain Model" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: domain, service, team", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that each domain model holds inside one explicit boundary, where its terms have one meaning.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Autonomy](/records/architecture/autonomy)", "term": "Reinforces" }, { "description": "[Context Mapping](/records/architecture/context-mapping), [Microservices](/records/architecture/microservices)", "term": "Enables" }, { "description": "[Cross-Context Reuse](/records/lexicon/cross-context-reuse)", "term": "In tension with" }, { "description": "[Shared Global Model](/records/lexicon/shared-global-model)", "term": "Conflicts with" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Context Mapping](/records/architecture/context-mapping), [Package by Feature](/records/architecture/package-by-feature), [Microservices](/records/architecture/microservices)", "term": "Referenced by" }, { "description": "[Domain Modeling](/records/algorithms/domain-modeling)", "term": "Contracts" }, { "description": "[Bounded Context / Cross-Context Reuse](/records/tension/bounded-context-cross-context-reuse)", "term": "Tensions" }, { "description": "[Relationship Semantics](/records/lexicon/relationship-semantics): A bounded context fixes meaning inside one boundary, while relationship semantics fixes the meaning of each link between boundaries.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Global Model](/records/lexicon/shared-global-model)", "term": "Violated by" }, { "description": "shared domain entities across contexts", "term": "Detected by" }, { "description": "context coupling", "term": "Measured by" }, { "description": "[Split Bounded Context](/records/lexicon/split-bounded-context), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Context Mapping](/records/architecture/context-mapping)", "term": "Refactored by" }, { "description": "package/service boundaries", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type FooStatus = \"A\" | \"D\";\nfunction priceBar(status: FooStatus) { return status === \"A\" ? 10 : 0; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooStatus = \"active\" | \"disabled\";\ntype BarEligibility = \"eligible\" | \"ineligible\";\nfunction toBarEligibility(status: FooStatus): BarEligibility {\n return status === \"active\" ? \"eligible\" : \"ineligible\";\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "package/service boundaries", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Modularity](/records/architecture/modularity), [Autonomy](/records/architecture/autonomy), [Context Mapping](/records/architecture/context-mapping), [Microservices](/records/architecture/microservices)", "term": "Depends on" }, { "description": "[Shared Global Model](/records/lexicon/shared-global-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-bounded-context", "title": "Bounded Context" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: bounded contexts, integration", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The activity of recording how bounded contexts relate, including which one is upstream and how their models translate.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Bounded Context](/records/architecture/bounded-context), [Relationship Semantics](/records/lexicon/relationship-semantics)", "term": "Requires" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Integration Clarity](/records/lexicon/integration-clarity)", "term": "Reinforces" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Enables" }, { "description": "[Documentation Overhead](/records/lexicon/documentation-overhead)", "term": "In tension with" }, { "description": "[Implicit Integration](/records/lexicon/implicit-integration)", "term": "Conflicts with" }, { "description": "[Bounded Context](/records/architecture/bounded-context)", "term": "Referenced by" }, { "description": "[Context Mapping / Documentation Overhead](/records/tension/context-mapping-documentation-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implicit Integration](/records/lexicon/implicit-integration)", "term": "Violated by" }, { "description": "unclear ownership, ambiguous integration flows", "term": "Detected by" }, { "description": "undocumented dependency count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "architecture docs, dependency reviews", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooService.writeDirectly(barDatabase, foo);\nbarService.readDirectly(fooDatabase, foo.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const contextMap = {\n upstream: \"FooContext\",\n downstream: \"BarContext\",\n relationship: \"published-language\",\n} as const;\nfooEvents.publish(toBarIntegrationEvent(foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture docs, dependency reviews", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Bounded Context](/records/architecture/bounded-context), [Relationship Semantics](/records/lexicon/relationship-semantics), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Integration Clarity](/records/lexicon/integration-clarity), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Depends on" }, { "description": "[Implicit Integration](/records/lexicon/implicit-integration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-context-mapping", "title": "Context Mapping" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: integration, bounded context boundary", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that translates an external system's model into the local domain's terms at the boundary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Boundary](/records/lexicon/explicit-boundary), [Translation Model](/records/lexicon/translation-model)", "term": "Requires" }, { "description": "[Domain Purity](/records/lexicon/domain-purity), [Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Legacy/System Integration](/records/lexicon/legacy-system-integration)", "term": "Enables" }, { "description": "[Mapping Overhead](/records/lexicon/mapping-overhead)", "term": "In tension with" }, { "description": "[Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage)", "term": "Conflicts with" }, { "description": "[Context Mapping](/records/architecture/context-mapping), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Referenced by" }, { "description": "[Anti-Corruption Layer Over Cross-Context Leak](/records/algorithms/no-leaky-context)", "term": "Contracts" }, { "description": "[Anti-Corruption Layer / Mapping Overhead](/records/tension/anti-corruption-layer-mapping-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct External Coupling](/records/lexicon/direct-external-coupling)", "term": "Violated by" }, { "description": "external DTOs used in domain layer", "term": "Detected by" }, { "description": "leakage count, adapter coverage", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto)", "term": "Refactored by" }, { "description": "import rules, layer tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createBar(fooResponse: FooApiResponse) {\n return barService.create({ foo_status: fooResponse.state_code });\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type BarInput = { eligible: boolean };\nfunction fromFoo(response: FooApiResponse): BarInput {\n return { eligible: response.state_code === \"A\" };\n}\nbarService.create(fromFoo(fooResponse));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules, layer tests", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Explicit Boundary](/records/lexicon/explicit-boundary), [Translation Model](/records/lexicon/translation-model), [Domain Purity](/records/lexicon/domain-purity), [Low Coupling](/records/architecture/low-coupling), [Legacy/System Integration](/records/lexicon/legacy-system-integration)", "term": "Depends on" }, { "description": "[Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage), [Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-anti-corruption-layer", "title": "Anti-Corruption Layer" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: module, component, service, domain", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each module declares its public interface and owner, and other modules reach it only through that interface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Ownership](/records/lexicon/ownership)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Replaceability](/records/architecture/replaceability), [Governance](/records/architecture/governance)", "term": "Enables" }, { "description": "[Cross-Cutting Concerns](/records/lexicon/cross-cutting-concerns)", "term": "In tension with" }, { "description": "[Boundary Leakage](/records/architecture/boundary-leakage)", "term": "Conflicts with" }, { "description": "[Bounded Context](/records/architecture/bounded-context), [Context Mapping](/records/architecture/context-mapping), [Aggregate](/records/architecture/aggregate), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Separation of Concerns](/records/architecture/separation-of-concerns), [High Cohesion](/records/architecture/high-cohesion), [Modularity](/records/architecture/modularity), [Independence](/records/architecture/independence), [Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Explicit Boundaries / Cross-Cutting Concerns](/records/tension/cross-cutting-concerns-explicit-boundaries)", "term": "Tensions" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction): Explicit boundaries declare a module's interface and owner, while declared jurisdiction declares which roots and files a naming gate governs.", "term": "Distinct from" }, { "description": "[Abstraction](/records/architecture/abstraction): Explicit boundaries fix where one module ends, while abstraction fixes how a concept is expressed without its detail.", "term": "Distinct from" }, { "description": "[Encapsulation](/records/architecture/encapsulation): Explicit boundaries govern access between modules, while encapsulation governs changes to one object's state.", "term": "Distinct from" }, { "description": "[Governance](/records/architecture/governance): Explicit boundaries are the declared interfaces, while governance holds decisions to shared policy.", "term": "Distinct from" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth): Explicit boundaries give each module one public interface, while a single source of truth gives each fact one owning definition.", "term": "Distinct from" }, { "description": "[Independence](/records/architecture/independence): Explicit boundaries declare the interface, while independence is testing and deploying a module without its neighbors.", "term": "Distinct from" }, { "description": "[Modularity](/records/architecture/modularity): Explicit boundaries declare each module's interface and owner, while modularity is the division into modules itself.", "term": "Distinct from" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns): Explicit boundaries declare interfaces, while separation of concerns decides which concerns sit on each side of them.", "term": "Distinct from" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility): Explicit boundaries declare interfaces, while single responsibility limits what sits behind one to one reason to change.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Boundary Leakage](/records/architecture/boundary-leakage), [Inappropriate Intimacy](/records/architecture/inappropriate-intimacy)", "term": "Violated by" }, { "description": "forbidden imports, [cyclic dependencies](/records/architecture/circular-dependency)", "term": "Detected by" }, { "description": "boundary violation count", "term": "Measured by" }, { "description": "[Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Define Contract](/records/lexicon/define-contract), [Restrict Exports](/records/lexicon/restrict-exports)", "term": "Refactored by" }, { "description": "module rules, architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "import { fooDatabase } from \"../../foo/infrastructure/database\";\nexport function loadBar(id: string) { return fooDatabase.query(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export interface FooGateway { find(id: FooId): Promise; }\nexport function loadBar(id: FooId, foos: FooGateway) { return foos.find(id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "module rules, architecture tests", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Ownership](/records/lexicon/ownership), [Modularity](/records/architecture/modularity), [Encapsulation](/records/architecture/encapsulation), [Replaceability](/records/architecture/replaceability), [Governance](/records/architecture/governance)", "term": "Depends on" }, { "description": "[Boundary Leakage](/records/architecture/boundary-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-explicit-boundaries", "title": "Explicit Boundaries" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, consistency boundary, bounded context", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that groups entities under one root, which is the only entry point and keeps the group's invariants.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Requires" }, { "description": "[Invariant](/records/architecture/invariant), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Transactional Consistency Boundary](/records/lexicon/transactional-consistency-boundary), [Root-Guarded Invariants](/records/lexicon/root-guarded-invariants)", "term": "Enables" }, { "description": "[Aggregate Size](/records/lexicon/aggregate-size)", "term": "In tension with" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Conflicts with" }, { "description": "[Domain Service](/records/architecture/domain-service)", "term": "Referenced by" }, { "description": "[Aggregate / Aggregate Size](/records/tension/aggregate-aggregate-size)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Violated by" }, { "description": "cross-entity invariant checks scattered in services", "term": "Detected by" }, { "description": "out-of-aggregate invariant enforcement count", "term": "Measured by" }, { "description": "[Add Aggregate Invariant](/records/lexicon/add-aggregate-invariant)", "term": "Refactored by" }, { "description": "domain model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooOrder.total -= item.price;\nfooOrderItems.delete(item.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooOrder {\n #items: FooItem[] = [];\n #total = 0;\n removeItem(id: FooItemId) {\n this.#items = this.#items.filter(item => item.id !== id);\n this.#total = this.#items.reduce((sum, item) => sum + item.price, 0);\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain model review", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Invariant](/records/architecture/invariant), [Encapsulation](/records/architecture/encapsulation), [Transactional Consistency Boundary](/records/lexicon/transactional-consistency-boundary), [Root-Guarded Invariants](/records/lexicon/root-guarded-invariants)", "term": "Depends on" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-aggregate", "title": "Aggregate" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: domain, modeling, immutability", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that models a domain value as an immutable, self-validating object compared by its attributes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Value Equality](/records/lexicon/value-equality)", "term": "Requires" }, { "description": "[Immutability](/records/architecture/immutability), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Self-Validating Values](/records/lexicon/self-validating-values), [Side-Effect-Free Equality](/records/lexicon/side-effect-free-equality)", "term": "Enables" }, { "description": "[Object Count](/records/lexicon/object-count)", "term": "In tension with" }, { "description": "[Primitive Obsession](/records/architecture/primitive-obsession), [Data Clumps](/records/architecture/data-clumps), [Long Parameter List](/records/architecture/long-parameter-list)", "term": "Conflicts with" }, { "description": "[Entity](/records/architecture/entity)", "term": "Referenced by" }, { "description": "[Value Object / Object Count](/records/tension/object-count-value-object)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Primitive Obsession](/records/architecture/primitive-obsession)", "term": "Violated by" }, { "description": "repeated validation of the same primitive shape", "term": "Detected by" }, { "description": "primitive-typed domain concept count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "domain model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function priceFoo(amount: number, currency: string) { return { amount, currency }; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Money {\n private constructor(readonly amount: number, readonly currency: string) {}\n static of(amount: number, currency: string): Money {\n if (amount < 0) throw new Error(\"negative money\");\n return new Money(amount, currency);\n }\n equals(other: Money) { return this.amount === other.amount && this.currency === other.currency; }\n add(other: Money): Money { return Money.of(this.amount + other.amount, this.currency); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain model review", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Value Equality](/records/lexicon/value-equality), [Immutability](/records/architecture/immutability), [Encapsulation](/records/architecture/encapsulation), [Self-Validating Values](/records/lexicon/self-validating-values), [Side-Effect-Free Equality](/records/lexicon/side-effect-free-equality)", "term": "Depends on" }, { "description": "[Primitive Obsession](/records/architecture/primitive-obsession), [Data Clumps](/records/architecture/data-clumps), [Long Parameter List](/records/architecture/long-parameter-list)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-value-object", "title": "Value Object" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, identity, lifecycle", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that models a domain object by a stable identity, which stays the same while its attributes change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Identity](/records/lexicon/stable-identity)", "term": "Requires" }, { "description": "[Domain Model](/records/architecture/domain-model), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Identity-Based Equality](/records/lexicon/identity-based-equality), [Lifecycle Tracking](/records/lexicon/lifecycle-tracking)", "term": "Enables" }, { "description": "[Value Object](/records/architecture/value-object)", "term": "In tension with" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Conflicts with" }, { "description": "[Entity / Value Object](/records/tension/entity-value-object)", "term": "Tensions" }, { "description": "[Value Object](/records/architecture/value-object): An entity is known by an identity that outlives its attributes, while a value object is known only by its attributes.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Attribute-Compared Identity](/records/lexicon/attribute-compared-identity)", "term": "Violated by" }, { "description": "equality by field value where identity is meant", "term": "Detected by" }, { "description": "attribute-equality misuse count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "domain model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type Foo = { id: string; name: string; status: string };\nfoo.status = \"active\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {\n constructor(readonly id: FooId, private name: string, private status: FooStatus) {}\n equals(other: Foo) { return this.id === other.id; }\n activate() { this.status = \"active\"; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain model review", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Stable Identity](/records/lexicon/stable-identity), [Domain Model](/records/architecture/domain-model), [Encapsulation](/records/architecture/encapsulation), [Identity-Based Equality](/records/lexicon/identity-based-equality), [Lifecycle Tracking](/records/lexicon/lifecycle-tracking)", "term": "Depends on" }, { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-entity", "title": "Entity" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Domain Architecture](/records/architecture-category/domain-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, behavior, coordination", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that places a domain rule spanning several entities in a stateless service named in the domain's language.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Domain Model](/records/architecture/domain-model)", "term": "Requires" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Reinforces" }, { "description": "[Cross-Entity Domain Logic](/records/lexicon/cross-entity-domain-logic)", "term": "Enables" }, { "description": "[Aggregate](/records/architecture/aggregate)", "term": "In tension with" }, { "description": "[Fat Controller](/records/architecture/fat-controller), [Transaction Script Sprawl](/records/architecture/transaction-script-sprawl)", "term": "Conflicts with" }, { "description": "[Domain Service / Aggregate](/records/tension/aggregate-domain-service)", "term": "Tensions" }, { "description": "[Aggregate](/records/architecture/aggregate): A domain service holds a stateless rule spanning entities, while an aggregate holds entities and their invariants under one root.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fat Controller](/records/architecture/fat-controller)", "term": "Violated by" }, { "description": "domain logic in application/transport layers", "term": "Detected by" }, { "description": "misplaced domain-rule count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "domain model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooAccount {\n transferTo(other: FooAccount, amount: number) {\n this.balance -= amount;\n other.balance += amount;\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooTransferService {\n transfer(from: FooAccount, to: FooAccount, amount: Money) {\n from.withdraw(amount);\n to.deposit(amount);\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain model review", "term": "Checked by" }, { "description": "Every domain type, business rule and context boundary in the domain layer", "term": "Population" }, { "description": "A verdict stands until a domain type, a rule's location or a context boundary changes", "term": "Freshness" }, { "description": "The layer rule or the domain test fails when a rule or a model leaves its context or its aggregate", "term": "Refusal" }, { "description": "Where each business rule and invariant is enforced, read from source and the domain tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The domain model, which decides the context and the aggregate every rule belongs to", "term": "Authoritative side" }, { "description": "[Domain Model](/records/architecture/domain-model), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Cross-Entity Domain Logic](/records/lexicon/cross-entity-domain-logic)", "term": "Depends on" }, { "description": "[Fat Controller](/records/architecture/fat-controller), [Transaction Script Sprawl](/records/architecture/transaction-script-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-domain-service", "title": "Domain Service" } ], "title": "Domain Architecture" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_runtime_discovery[\"Runtime Discovery\"]\n n_service_discovery[\"Service Discovery\"]\n n_dynamic_binding[\"Dynamic Binding\"]\n n_dynamic_dispatch[\"Dynamic Dispatch\"]\n n_runtime_extensibility[\"Runtime Extensibility\"]\n n_runtime_discovery --> n_runtime_extensibility\n n_runtime_discovery --> n_service_discovery\n n_dynamic_binding --> n_runtime_extensibility" } ], "icon": "bi-collection", "id": "architecture-category-runtime-discovery-dynamic-binding", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Runtime Discovery / Dynamic Binding](/records/architecture-category/runtime-discovery-dynamic-binding)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, plugin, module, service", "Aliases: Auto-Discovery, Registry/Discovery Mechanism", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that finds the available handlers, plugins or services at startup by matching a naming convention, a file pattern or metadata, and registers each one it finds in place of a hand-written list.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Metadata](/records/lexicon/metadata), [Convention](/records/lexicon/convention)", "term": "Requires" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Reinforces" }, { "description": "[Plugin Architecture](/records/architecture/plugin-architecture), [Service Discovery](/records/architecture/service-discovery), [Self-Registration](/records/lexicon/self-registration)", "term": "Enables" }, { "description": "[Predictability](/records/architecture/predictability), [Static Analysis](/records/architecture/static-analysis), [Startup Cost](/records/lexicon/startup-cost)", "term": "In tension with" }, { "description": "[Compile-Time Binding](/records/lexicon/compile-time-binding), [Manual Registration](/records/lexicon/manual-registration)", "term": "Conflicts with" }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Capability Declaration](/records/architecture/capability-declaration), [Manifest-Based Design](/records/architecture/manifest-based-design), [Reflection](/records/architecture/reflection)", "term": "Referenced by" }, { "description": "[Runtime Discovery](/records/algorithms/runtime-discovery)", "term": "Contracts" }, { "description": "[Runtime Discovery / Predictability](/records/tension/predictability-runtime-discovery), [Runtime Discovery / Static Analysis](/records/tension/runtime-discovery-static-analysis), [Runtime Discovery / Startup Cost](/records/tension/runtime-discovery-startup-cost)", "term": "Tensions" }, { "description": "[Capability Declaration](/records/architecture/capability-declaration): Runtime discovery finds which components exist, while a capability declaration states what each one supports.", "term": "Distinct from" }, { "description": "[Introspection](/records/architecture/introspection): Runtime discovery finds components by convention or pattern, while introspection reads one object's type and members.", "term": "Distinct from" }, { "description": "[Reflection](/records/architecture/reflection): Runtime discovery finds and registers components, while reflection reads and acts on type metadata, which discovery may use.", "term": "Distinct from" }, { "description": "[Service Discovery](/records/architecture/service-discovery): Runtime discovery finds in-process components at startup, while service discovery resolves a service name to a network endpoint at call time.", "term": "Distinct from" }, { "description": "[Static Analysis](/records/architecture/static-analysis): Runtime discovery decides the component set as the program starts, while static analysis reasons about source that has not run.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual Registration](/records/lexicon/manual-registration)", "term": "Violated by" }, { "description": "manual class/service lists", "term": "Detected by" }, { "description": "discovery coverage", "term": "Measured by" }, { "description": "[Registry Pattern](/records/architecture/registry-pattern), [Static Analysis](/records/architecture/static-analysis), [Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Refactored by" }, { "description": "startup validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "import { FooHandler } from \"./foo-handler\";\nimport { BarHandler } from \"./bar-handler\";\nconst handlers = [new FooHandler(), new BarHandler()];", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const modules = await discover(\"./handlers/*.handler.js\");\nconst handlers = modules.map(module => module.create());", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "startup validation", "term": "Checked by" }, { "description": "Every binding the runtime resolves: handlers, plugins, services, formatters and policies", "term": "Population" }, { "description": "A verdict stands until a registered module, a discovery pattern or the configuration changes", "term": "Freshness" }, { "description": "Startup validation or the composition-root test fails when a declared binding resolves to nothing", "term": "Refusal" }, { "description": "The resolved bindings reported at startup, compared with the modules on disk and the configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The modules on disk and the configuration, which the bindings reported at startup are compared against", "term": "Authoritative side" }, { "description": "[Metadata](/records/lexicon/metadata), [Convention](/records/lexicon/convention), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Plugin Architecture](/records/architecture/plugin-architecture), [Service Discovery](/records/architecture/service-discovery), [Self-Registration](/records/lexicon/self-registration)", "term": "Depends on" }, { "description": "[Compile-Time Binding](/records/lexicon/compile-time-binding), [Manual Registration](/records/lexicon/manual-registration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-runtime-discovery", "title": "Runtime Discovery" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Runtime Discovery / Dynamic Binding](/records/architecture-category/runtime-discovery-dynamic-binding)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, network, runtime", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that resolves a service name to a healthy network endpoint at call time through a registry.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Service Registry](/records/architecture/service-registry), [Health Checks](/records/architecture/health-checks)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Dynamic Routing](/records/lexicon/dynamic-routing), [Failover](/records/architecture/failover)", "term": "Enables" }, { "description": "[Operational Complexity](/records/lexicon/operational-complexity)", "term": "In tension with" }, { "description": "[Hardcoded Endpoints](/records/lexicon/hardcoded-endpoints)", "term": "Conflicts with" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Referenced by" }, { "description": "[Service Discovery / Operational Complexity](/records/tension/operational-complexity-service-discovery)", "term": "Tensions" }, { "description": "[Failover](/records/architecture/failover): Service discovery resolves a name to a healthy endpoint, while failover switches traffic to a standby when the active one fails.", "term": "Distinct from" }, { "description": "[Health Checks](/records/architecture/health-checks): Service discovery resolves endpoints, while health checks report whether each endpoint is ready.", "term": "Distinct from" }, { "description": "[Service Registry](/records/architecture/service-registry): Service discovery is the lookup at call time, while the service registry is the table the lookup reads.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Endpoints](/records/lexicon/hardcoded-endpoints)", "term": "Violated by" }, { "description": "hardcoded URLs, missing registry lookup", "term": "Detected by" }, { "description": "dynamic resolution coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "config scans, deployment policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooUrl = \"http://10.0.0.14:8080\";\nawait http.get(`${fooUrl}/foo/${id}`);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const endpoint = await serviceDiscovery.resolve(\"foo-service\");\nawait http.get(new URL(`/foo/${id}`, endpoint));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "config scans, deployment policy", "term": "Checked by" }, { "description": "Every binding the runtime resolves: handlers, plugins, services, formatters and policies", "term": "Population" }, { "description": "A verdict stands until a registered module, a discovery pattern or the configuration changes", "term": "Freshness" }, { "description": "Startup validation or the composition-root test fails when a declared binding resolves to nothing", "term": "Refusal" }, { "description": "The resolved bindings reported at startup, compared with the modules on disk and the configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The modules on disk and the configuration, which the bindings reported at startup are compared against", "term": "Authoritative side" }, { "description": "[Service Registry](/records/architecture/service-registry), [Health Checks](/records/architecture/health-checks), [Scalability](/records/architecture/scalability), [Resilience](/records/architecture/resilience), [Dynamic Routing](/records/lexicon/dynamic-routing), [Failover](/records/architecture/failover)", "term": "Depends on" }, { "description": "[Hardcoded Endpoints](/records/lexicon/hardcoded-endpoints)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-service-discovery", "title": "Service Discovery" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Runtime Discovery / Dynamic Binding](/records/architecture-category/runtime-discovery-dynamic-binding)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, interface, plugin, module, service", "Aliases: Late Binding, Runtime Binding", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that selects the implementation behind an interface at runtime, from configuration or a registry, so the choice is made at bootstrap or first use rather than fixed in code.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Runtime Resolution](/records/lexicon/runtime-resolution)", "term": "Requires" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Extensibility](/records/lexicon/extensibility), [Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Reinforces" }, { "description": "[Strategy Swap](/records/lexicon/strategy-swap), [Deferred Implementation Choice](/records/lexicon/deferred-implementation-choice)", "term": "Enables" }, { "description": "[Static Safety](/records/lexicon/static-safety), [Predictability](/records/architecture/predictability), [Debugging](/records/lexicon/debugging)", "term": "In tension with" }, { "description": "[Compile-Time Binding](/records/lexicon/compile-time-binding)", "term": "Conflicts with" }, { "description": "[Capability Declaration](/records/architecture/capability-declaration), [Reflection](/records/architecture/reflection), [Service Registry](/records/architecture/service-registry)", "term": "Referenced by" }, { "description": "[Dynamic Binding / Static Safety](/records/tension/dynamic-binding-static-safety), [Dynamic Binding / Predictability](/records/tension/dynamic-binding-predictability), [Dynamic Binding / Debugging](/records/tension/debugging-dynamic-binding)", "term": "Tensions" }, { "description": "[Capability Declaration](/records/architecture/capability-declaration): Dynamic binding picks an implementation at runtime, while a capability declaration lists what an implementation supports so the pick can be checked.", "term": "Distinct from" }, { "description": "[Polymorphism](/records/architecture/polymorphism): Polymorphism lets the receiver choose the implementation per call, while dynamic binding chooses it from configuration or a registry.", "term": "Distinct from" }, { "description": "[Service Registry](/records/architecture/service-registry): Dynamic binding is the choice made at runtime, while a service registry is the keyed table it can choose from.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Compile-Time Binding](/records/lexicon/compile-time-binding)", "term": "Violated by" }, { "description": "hardcoded implementation selection", "term": "Detected by" }, { "description": "runtime binding coverage", "term": "Measured by" }, { "description": "[Factory Pattern](/records/architecture/factory-pattern), [Registry](/records/lexicon/registry), [Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Refactored by" }, { "description": "integration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const formatter = new JsonFooFormatter();\nformatter.format(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const formatter = formatterRegistry.get(config.format);\nif (!formatter) throw new Error(`unknown formatter: ${config.format}`);\nformatter.format(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "integration tests", "term": "Checked by" }, { "description": "Every binding the runtime resolves: handlers, plugins, services, formatters and policies", "term": "Population" }, { "description": "A verdict stands until a registered module, a discovery pattern or the configuration changes", "term": "Freshness" }, { "description": "Startup validation or the composition-root test fails when a declared binding resolves to nothing", "term": "Refusal" }, { "description": "The resolved bindings reported at startup, compared with the modules on disk and the configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The modules on disk and the configuration, which the bindings reported at startup are compared against", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Runtime Resolution](/records/lexicon/runtime-resolution), [Polymorphism](/records/architecture/polymorphism), [Extensibility](/records/lexicon/extensibility), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Strategy Swap](/records/lexicon/strategy-swap), [Deferred Implementation Choice](/records/lexicon/deferred-implementation-choice)", "term": "Depends on" }, { "description": "[Compile-Time Binding](/records/lexicon/compile-time-binding)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dynamic-binding", "title": "Dynamic Binding" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Runtime Discovery / Dynamic Binding](/records/architecture-category/runtime-discovery-dynamic-binding)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: method, interface, runtime", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that chooses which operation runs from the receiver or a keyed table at runtime, replacing a conditional over kinds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Polymorphism](/records/architecture/polymorphism)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Reinforces" }, { "description": "[Replace Conditional with Polymorphism](/records/lexicon/replace-conditional-with-polymorphism)", "term": "Enables" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "In tension with" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Conflicts with" }, { "description": "[Polymorphism](/records/architecture/polymorphism)", "term": "Referenced by" }, { "description": "[Dynamic Dispatch / Traceability](/records/tension/dynamic-dispatch-traceability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Violated by" }, { "description": "switch/if chains on type", "term": "Detected by" }, { "description": "conditional dispatch count", "term": "Measured by" }, { "description": "[Replace Conditional with Polymorphism](/records/lexicon/replace-conditional-with-polymorphism), [Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Refactored by" }, { "description": "lint rules, [review](/records/lexicon/review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function execute(kind: string, foo: Foo) {\n if (kind === \"save\") return saveFoo(foo);\n if (kind === \"publish\") return publishFoo(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const commands: Record unknown> = {\n save: saveFoo,\n publish: publishFoo,\n};\nfunction execute(kind: string, foo: Foo) {\n const command = commands[kind];\n if (!command) throw new Error(`unknown command ${kind}`);\n return command(foo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules, review", "term": "Checked by" }, { "description": "Every binding the runtime resolves: handlers, plugins, services, formatters and policies", "term": "Population" }, { "description": "A verdict stands until a registered module, a discovery pattern or the configuration changes", "term": "Freshness" }, { "description": "Startup validation or the composition-root test fails when a declared binding resolves to nothing", "term": "Refusal" }, { "description": "The resolved bindings reported at startup, compared with the modules on disk and the configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The modules on disk and the configuration, which the bindings reported at startup are compared against", "term": "Authoritative side" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Replace Conditional with Polymorphism](/records/lexicon/replace-conditional-with-polymorphism)", "term": "Depends on" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dynamic-dispatch", "title": "Dynamic Dispatch" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Runtime Discovery / Dynamic Binding](/records/architecture-category/runtime-discovery-dynamic-binding)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, plugin, system", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which new capability can be added to a running system through extension points, without modifying its core.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Extension Points](/records/architecture/extension-points), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Plugin Architecture](/records/architecture/plugin-architecture), [Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Reinforces" }, { "description": "[Capability Addition without Core Modification](/records/lexicon/capability-addition-without-core-modification)", "term": "Enables" }, { "description": "[Predictability](/records/architecture/predictability), [Security](/records/lexicon/security)", "term": "In tension with" }, { "description": "[Closed Static Core](/records/lexicon/closed-static-core)", "term": "Conflicts with" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Dynamic Binding](/records/architecture/dynamic-binding), [Runtime Code Generation](/records/architecture/runtime-code-generation), [Prototype Pattern](/records/architecture/prototype-pattern), [Plugin Architecture](/records/architecture/plugin-architecture), [Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" }, { "description": "[Runtime Extensibility](/records/algorithms/runtime-extensibility)", "term": "Contracts" }, { "description": "[Runtime Extensibility / Predictability](/records/tension/predictability-runtime-extensibility), [Runtime Extensibility / Security](/records/tension/runtime-extensibility-security)", "term": "Tensions" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces): Runtime extensibility adds capability through extension points, while stable interfaces keep those points unchanged across releases.", "term": "Distinct from" }, { "description": "[Extensibility](/records/lexicon/extensibility): Extensibility is adding behavior with little change to existing code, while runtime extensibility adds it to a system that is already running.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Closed Core](/records/lexicon/closed-core)", "term": "Violated by" }, { "description": "repeated core changes for variants", "term": "Detected by" }, { "description": "extension/core-change ratio", "term": "Measured by" }, { "description": "[Extension Points](/records/architecture/extension-points)", "term": "Refactored by" }, { "description": "extension conformance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "switch (pluginName) {\n case \"foo\": return new FooPlugin();\n case \"bar\": return new BarPlugin();\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export function registerPlugin(name: string, create: () => Plugin) {\n pluginRegistry.set(name, create);\n}\nconst plugin = pluginRegistry.get(pluginName)?.();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "extension conformance tests", "term": "Checked by" }, { "description": "Every binding the runtime resolves: handlers, plugins, services, formatters and policies", "term": "Population" }, { "description": "A verdict stands until a registered module, a discovery pattern or the configuration changes", "term": "Freshness" }, { "description": "Startup validation or the composition-root test fails when a declared binding resolves to nothing", "term": "Refusal" }, { "description": "The resolved bindings reported at startup, compared with the modules on disk and the configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The modules on disk and the configuration, which the bindings reported at startup are compared against", "term": "Authoritative side" }, { "description": "[Extension Points](/records/architecture/extension-points), [Stable Interfaces](/records/architecture/stable-interfaces), [Plugin Architecture](/records/architecture/plugin-architecture), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Capability Addition without Core Modification](/records/lexicon/capability-addition-without-core-modification)", "term": "Depends on" }, { "description": "[Closed Static Core](/records/lexicon/closed-static-core)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-runtime-extensibility", "title": "Runtime Extensibility" } ], "title": "Runtime Discovery / Dynamic Binding" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_causality[\"Causality\"]\n n_causal_consistency[\"Causal Consistency\"]\n n_happens_before_relationship[\"Happens-Before Relationship\"]\n n_event_ordering[\"Event Ordering\"]\n n_causal_dependency[\"Causal Dependency\"]\n n_dependency_graph[\"Dependency Graph\"]\n n_directed_acyclic_graph[\"Directed Acyclic Graph (DAG)\"]\n n_vector_clocks[\"Vector Clocks\"]\n n_lamport_clocks[\"Lamport Clocks\"]\n n_hybrid_logical_clocks[\"Hybrid Logical Clocks\"]\n n_crdts[\"CRDTs\"]\n n_total_order_broadcast[\"Total-Order Broadcast\"]\n n_cap_theorem[\"CAP Theorem\"]\n n_pacelc_theorem[\"PACELC Theorem\"]\n n_causality --> n_event_ordering\n n_event_ordering --> n_causality\n n_causal_dependency --> n_causality\n n_vector_clocks --> n_causal_consistency\n n_hybrid_logical_clocks --> n_happens_before_relationship\n n_hybrid_logical_clocks --> n_causal_consistency\n n_hybrid_logical_clocks --> n_event_ordering\n n_crdts --> n_causal_consistency\n n_total_order_broadcast --> n_event_ordering\n n_cap_theorem --> n_causal_consistency\n n_pacelc_theorem --> n_cap_theorem\n n_pacelc_theorem --> n_cap_theorem" } ], "icon": "bi-collection", "id": "architecture-category-causality-ordering-distributed-time", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: event, workflow, distributed state", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every effect records the event that caused it, so its order can be reasoned about.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Causation Tracking](/records/lexicon/causation-tracking)", "term": "Requires" }, { "description": "[Traceability](/records/architecture/traceability), [Event Ordering](/records/architecture/event-ordering)", "term": "Reinforces" }, { "description": "[Correct Workflow Reasoning](/records/lexicon/correct-workflow-reasoning)", "term": "Enables" }, { "description": "[Parallelism](/records/architecture/parallelism)", "term": "In tension with" }, { "description": "[Unordered Side Effects](/records/lexicon/unordered-side-effects)", "term": "Conflicts with" }, { "description": "[Event Ordering](/records/architecture/event-ordering), [Causal Dependency](/records/architecture/causal-dependency), [Causation ID](/records/architecture/causation-id), [Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Referenced by" }, { "description": "[Causality Core](/records/algorithms/causality-core)", "term": "Contracts" }, { "description": "[Causality / Parallelism](/records/tension/causality-parallelism)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unlinked Events](/records/lexicon/unlinked-events)", "term": "Violated by" }, { "description": "missing causation/correlation metadata", "term": "Detected by" }, { "description": "causal trace completeness", "term": "Measured by" }, { "description": "[Causation ID](/records/architecture/causation-id), [Make Order Explicit](/records/lexicon/make-order-explicit)", "term": "Refactored by" }, { "description": "event schema and workflow tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "events.push({ type: \"BarCreated\", at: Date.now() });\nevents.push({ type: \"FooCreated\", at: Date.now() });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooCreated = append({ type: \"FooCreated\" });\nappend({ type: \"BarCreated\", causedBy: fooCreated.id });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "event schema and workflow tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Causation Tracking](/records/lexicon/causation-tracking), [Traceability](/records/architecture/traceability), [Event Ordering](/records/architecture/event-ordering), [Correct Workflow Reasoning](/records/lexicon/correct-workflow-reasoning)", "term": "Depends on" }, { "description": "[Unordered Side Effects](/records/lexicon/unordered-side-effects)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-causality", "title": "Causality" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed data, events", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a consistency guarantee in which no reader sees an effect before its cause.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Causal Ordering](/records/lexicon/causal-ordering)", "term": "Requires" }, { "description": "[Eventual Consistency Safety](/records/lexicon/eventual-consistency-safety)", "term": "Reinforces" }, { "description": "[User-Visible Ordering Guarantees](/records/lexicon/user-visible-ordering-guarantees)", "term": "Enables" }, { "description": "[Latency/Availability](/records/lexicon/latency-availability)", "term": "In tension with" }, { "description": "[Arbitrary Reordering](/records/lexicon/arbitrary-reordering), [Read-Your-Writes Violation](/records/architecture/read-your-writes-violation)", "term": "Conflicts with" }, { "description": "[Vector Clocks](/records/architecture/vector-clocks), [Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks), [CRDTs](/records/architecture/crdts), [CAP Theorem](/records/architecture/cap-theorem)", "term": "Referenced by" }, { "description": "[Causal Consistency / Latency/Availability](/records/tension/causal-consistency-latency-availability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Arbitrary Reordering](/records/lexicon/arbitrary-reordering)", "term": "Violated by" }, { "description": "order anomaly tests", "term": "Detected by" }, { "description": "causal anomaly rate", "term": "Measured by" }, { "description": "[Causation ID](/records/architecture/causation-id), [Read From Primary After Write](/records/lexicon/read-from-primary-after-write)", "term": "Refactored by" }, { "description": "consistency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "replica.apply(barCreated);\nreplica.apply(fooCreated);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "replica.applyWhenReady(barCreated, {\n requires: [fooCreated.id],\n});\nreplica.apply(fooCreated);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "consistency tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Causal Ordering](/records/lexicon/causal-ordering), [Eventual Consistency Safety](/records/lexicon/eventual-consistency-safety), [User-Visible Ordering Guarantees](/records/lexicon/user-visible-ordering-guarantees)", "term": "Depends on" }, { "description": "[Arbitrary Reordering](/records/lexicon/arbitrary-reordering), [Read-Your-Writes Violation](/records/architecture/read-your-writes-violation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-causal-consistency", "title": "Causal Consistency" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: concurrency, distributed events", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the partial order in which one operation is known to precede another.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ordering Semantics](/records/lexicon/ordering-semantics)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Causal Reasoning](/records/lexicon/causal-reasoning)", "term": "Reinforces" }, { "description": "[Race Detection](/records/lexicon/race-detection)", "term": "Enables" }, { "description": "[Parallel Execution](/records/lexicon/parallel-execution)", "term": "In tension with" }, { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Conflicts with" }, { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Referenced by" }, { "description": "[Happens-Before Relationship / Parallel Execution](/records/tension/happens-before-relationship-parallel-execution)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Violated by" }, { "description": "race detectors, missing synchronization", "term": "Detected by" }, { "description": "ordering violation count", "term": "Measured by" }, { "description": "[Apply Concurrency Control](/records/lexicon/apply-concurrency-control), [Make Order Explicit](/records/lexicon/make-order-explicit)", "term": "Refactored by" }, { "description": "concurrency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const a = { id: \"a\", at: Date.now() };\nconst b = { id: \"b\", at: Date.now() };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const a = { id: \"a\", ordinal: 1 };\nconst b = { id: \"b\", ordinal: 2, after: [a.id] };\nassert(happensBefore(a, b));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "concurrency tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Ordering Semantics](/records/lexicon/ordering-semantics), [Correctness](/records/architecture/correctness), [Causal Reasoning](/records/lexicon/causal-reasoning), [Race Detection](/records/lexicon/race-detection)", "term": "Depends on" }, { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-happens-before-relationship", "title": "Happens-Before Relationship" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: stream, queue, consumer", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a stateful consumer processes the events of one key in their sequence order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ordering Key or Sequence](/records/lexicon/ordering-key-or-sequence)", "term": "Requires" }, { "description": "[Causality](/records/architecture/causality)", "term": "Reinforces" }, { "description": "[Correct Stateful Processing](/records/lexicon/correct-stateful-processing)", "term": "Enables" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "In tension with" }, { "description": "[Unordered Parallel Consumption](/records/lexicon/unordered-parallel-consumption)", "term": "Conflicts with" }, { "description": "[Causality](/records/architecture/causality), [Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks), [Total-Order Broadcast](/records/architecture/total-order-broadcast)", "term": "Referenced by" }, { "description": "[Event Ordering / Throughput](/records/tension/event-ordering-throughput)", "term": "Tensions" }, { "description": "[Ordering Key or Sequence](/records/lexicon/ordering-key-or-sequence): Event ordering binds the consumer to process one key's events in order, while the ordering key is the field on each event that makes the order known.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unordered Parallel Consumption](/records/lexicon/unordered-parallel-consumption)", "term": "Violated by" }, { "description": "missing ordering key/sequence checks", "term": "Detected by" }, { "description": "out-of-order rate", "term": "Measured by" }, { "description": "[Partitioning](/records/architecture/partitioning), [Logical Counter](/records/lexicon/logical-counter), [Reorder Buffer](/records/lexicon/reorder-buffer)", "term": "Refactored by" }, { "description": "stream config, consumer tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "events.sort((a, b) => a.timestamp - b.timestamp);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "events.sort((a, b) => a.streamOrdinal - b.streamOrdinal);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "stream config, consumer tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Ordering Key or Sequence](/records/lexicon/ordering-key-or-sequence), [Causality](/records/architecture/causality), [Correct Stateful Processing](/records/lexicon/correct-stateful-processing)", "term": "Depends on" }, { "description": "[Unordered Parallel Consumption](/records/lexicon/unordered-parallel-consumption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-event-ordering", "title": "Event Ordering" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: event, workflow, module", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of one step or event that cannot proceed until another has happened.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Dependency Declaration](/records/lexicon/dependency-declaration)", "term": "Requires" }, { "description": "[Causality](/records/architecture/causality), [Traceability](/records/architecture/traceability)", "term": "Reinforces" }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Enables" }, { "description": "[Graph Complexity](/records/lexicon/graph-complexity)", "term": "In tension with" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Conflicts with" }, { "description": "[Causal Dependency / Graph Complexity](/records/tension/causal-dependency-graph-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "undocumented call/event dependency", "term": "Detected by" }, { "description": "hidden dependency count", "term": "Measured by" }, { "description": "[Explicit Dependency](/records/lexicon/explicit-dependency), [Causation ID](/records/architecture/causation-id)", "term": "Refactored by" }, { "description": "dependency graph checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "processBar(barEvent);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (!projection.has(barEvent.fooEventId)) defer(barEvent);\nelse processBar(barEvent);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency graph checks", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Dependency Declaration](/records/lexicon/dependency-declaration), [Causality](/records/architecture/causality), [Traceability](/records/architecture/traceability), [Impact Analysis](/records/architecture/impact-analysis)", "term": "Depends on" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-causal-dependency", "title": "Causal Dependency" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: codebase, runtime, deployment", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about which modules, tasks or services depend on which, extracted as a directed graph.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Dependency Extraction](/records/lexicon/dependency-extraction)", "term": "Requires" }, { "description": "[Architecture Compliance](/records/lexicon/architecture-compliance)", "term": "Reinforces" }, { "description": "[Cycle Detection](/records/lexicon/cycle-detection), [Impact Analysis](/records/architecture/impact-analysis)", "term": "Enables" }, { "description": "[Dynamic Loading](/records/lexicon/dynamic-loading)", "term": "In tension with" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Conflicts with" }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Referenced by" }, { "description": "[Dependency Graph / Dynamic Loading](/records/tension/dependency-graph-dynamic-loading)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "graph extraction mismatch", "term": "Detected by" }, { "description": "cycle count, graph density", "term": "Measured by" }, { "description": "[Invert Dependency](/records/lexicon/invert-dependency)", "term": "Refactored by" }, { "description": "dependency graph CI checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const tasks = [loadFoo, buildBar, publishBaz];\nawait Promise.all(tasks.map(task => task()));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const graph = new DependencyGraph();\ngraph.add(\"buildBar\", { dependsOn: [\"loadFoo\"] });\ngraph.add(\"publishBaz\", { dependsOn: [\"buildBar\"] });\nawait graph.execute();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency graph CI checks", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Dependency Extraction](/records/lexicon/dependency-extraction), [Architecture Compliance](/records/lexicon/architecture-compliance), [Cycle Detection](/records/lexicon/cycle-detection), [Impact Analysis](/records/architecture/impact-analysis)", "term": "Depends on" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dependency-graph", "title": "Dependency Graph" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: dependency architecture", "Scope: dependency graph, workflow, build", "Aliases: Directed Dependencies", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that every dependency points one way and the graph they form has no cycle, so its nodes can be put in topological order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "[Layering](/records/lexicon/layering), [Build Order](/records/lexicon/build-order)", "term": "Reinforces" }, { "description": "[Topological Ordering](/records/lexicon/topological-ordering)", "term": "Enables" }, { "description": "[Bidirectional Collaboration](/records/lexicon/bidirectional-collaboration)", "term": "In tension with" }, { "description": "[Circular Dependency](/records/architecture/circular-dependency)", "term": "Conflicts with" }, { "description": "[Checklist Creation Kernel](/records/algorithms/checklist-creation-kernel)", "term": "Contracts" }, { "description": "[Directed Acyclic Graph (DAG) / Bidirectional Collaboration](/records/tension/bidirectional-collaboration-directed-acyclic-graph-dag)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Circular Dependency](/records/architecture/circular-dependency)", "term": "Violated by" }, { "description": "[cycle detection](/records/lexicon/cycle-detection)", "term": "Detected by" }, { "description": "cycle count", "term": "Measured by" }, { "description": "[Invert Dependency](/records/lexicon/invert-dependency), [Extract Interface](/records/lexicon/extract-interface), [Split Module](/records/lexicon/split-module)", "term": "Refactored by" }, { "description": "graph checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "graph.addEdge(\"foo\", \"bar\");\ngraph.addEdge(\"bar\", \"foo\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const dag = new Dag();\ndag.addEdge(\"foo\", \"bar\");\nif (dag.wouldCreateCycle(\"bar\", \"foo\")) throw new Error(\"cycle rejected\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "graph checks", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Layering](/records/lexicon/layering), [Build Order](/records/lexicon/build-order), [Topological Ordering](/records/lexicon/topological-ordering)", "term": "Depends on" }, { "description": "[Circular Dependency](/records/architecture/circular-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-directed-acyclic-graph", "title": "Directed Acyclic Graph (DAG)" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed events, replication", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that keeps one counter per node on each update, so two updates can be compared as ordered or concurrent.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Node Identity](/records/lexicon/node-identity), [Version Vector](/records/lexicon/version-vector)", "term": "Requires" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Reinforces" }, { "description": "[Concurrent Update Detection](/records/lexicon/concurrent-update-detection)", "term": "Enables" }, { "description": "[Metadata Size](/records/lexicon/metadata-size)", "term": "In tension with" }, { "description": "[Single Global Clock Assumption](/records/lexicon/single-global-clock-assumption)", "term": "Conflicts with" }, { "description": "[Vector Clocks / Metadata Size](/records/tension/metadata-size-vector-clocks)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Violated by" }, { "description": "lost causality in distributed updates", "term": "Detected by" }, { "description": "conflict detection accuracy", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "replication protocol tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const winner = a.updatedAt > b.updatedAt ? a : b;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const relation = compareVectorClocks(a.clock, b.clock);\nif (relation === \"concurrent\") return mergeFoo(a, b);\nreturn relation === \"after\" ? a : b;", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "replication protocol tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Node Identity](/records/lexicon/node-identity), [Version Vector](/records/lexicon/version-vector), [Causal Consistency](/records/architecture/causal-consistency), [Concurrent Update Detection](/records/lexicon/concurrent-update-detection)", "term": "Depends on" }, { "description": "[Single Global Clock Assumption](/records/lexicon/single-global-clock-assumption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-vector-clocks", "title": "Vector Clocks" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed events", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that stamps each event with a logical counter, advanced on every send and receive, to give a partial order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Logical Counter](/records/lexicon/logical-counter)", "term": "Requires" }, { "description": "[Happens-Before Reasoning](/records/lexicon/happens-before-reasoning)", "term": "Reinforces" }, { "description": "[Partial Ordering](/records/lexicon/partial-ordering)", "term": "Enables" }, { "description": "[No Concurrent Causality Distinction](/records/lexicon/no-concurrent-causality-distinction)", "term": "In tension with" }, { "description": "[Wall-Clock Ordering Assumption](/records/lexicon/wall-clock-ordering-assumption)", "term": "Conflicts with" }, { "description": "[Lamport Clocks / No Concurrent Causality Distinction](/records/tension/lamport-clocks-no-concurrent-causality-distinction)", "term": "Tensions" }, { "description": "[Logical Counter](/records/lexicon/logical-counter): Lamport clocks are the whole stamping scheme, advanced on every send and receive, while the logical counter is the value each process keeps.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Wall-Clock Ordering Assumption](/records/lexicon/wall-clock-ordering-assumption)", "term": "Violated by" }, { "description": "timestamp ordering anomalies", "term": "Detected by" }, { "description": "ordering anomaly rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "protocol tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const event = { at: Date.now(), value: foo };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const event = { logicalTime: lamport.tick(), value: foo };\nlamport.observe(remoteEvent.logicalTime);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "protocol tests", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Logical Counter](/records/lexicon/logical-counter), [Happens-Before Reasoning](/records/lexicon/happens-before-reasoning), [Partial Ordering](/records/lexicon/partial-ordering)", "term": "Depends on" }, { "description": "[Wall-Clock Ordering Assumption](/records/lexicon/wall-clock-ordering-assumption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-lamport-clocks", "title": "Lamport Clocks" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: event, distributed state, time", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that combines physical time with a logical counter, so timestamps follow causal order and stay close to wall-clock time.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Requires" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency), [Event Ordering](/records/architecture/event-ordering)", "term": "Reinforces" }, { "description": "[Wall-Clock-Correlated Causal Order](/records/lexicon/wall-clock-correlated-causal-order)", "term": "Enables" }, { "description": "[Clock Skew](/records/lexicon/clock-skew)", "term": "In tension with" }, { "description": "[Physical-Clock-Only Ordering](/records/lexicon/physical-clock-only-ordering)", "term": "Conflicts with" }, { "description": "[Hybrid Logical Clocks / Clock Skew](/records/tension/clock-skew-hybrid-logical-clocks)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Physical-Clock-Only Ordering](/records/lexicon/physical-clock-only-ordering)", "term": "Violated by" }, { "description": "last-writer-wins on physical time", "term": "Detected by" }, { "description": "out-of-causal-order event rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const event = { at: Date.now(), value: foo };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const event = { hlc: hlc.now(), value: foo };\nhlc.update(remoteEvent.hlc);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship), [Causal Consistency](/records/architecture/causal-consistency), [Event Ordering](/records/architecture/event-ordering), [Wall-Clock-Correlated Causal Order](/records/lexicon/wall-clock-correlated-causal-order)", "term": "Depends on" }, { "description": "[Physical-Clock-Only Ordering](/records/lexicon/physical-clock-only-ordering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-hybrid-logical-clocks", "title": "Hybrid Logical Clocks" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed state, replication, convergence", "Aliases: Conflict-Free Replicated Data Types", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that stores replicated state in data types whose merge is commutative, so replicas converge without coordination.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Commutative Merge](/records/lexicon/commutative-merge)", "term": "Requires" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency), [Causal Consistency](/records/architecture/causal-consistency)", "term": "Reinforces" }, { "description": "[Conflict-Free Replica Convergence](/records/lexicon/conflict-free-replica-convergence)", "term": "Enables" }, { "description": "[Metadata Overhead](/records/lexicon/metadata-overhead), [Last-Write-Wins Overwrite](/records/lexicon/last-write-wins-overwrite)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[CRDTs / Metadata Overhead](/records/tension/crdts-metadata-overhead), [CRDTs / Last-Write-Wins Overwrite](/records/tension/crdts-last-write-wins-overwrite)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Violated by" }, { "description": "lost updates under concurrent replication", "term": "Detected by" }, { "description": "merge-conflict data-loss rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "replication design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.tags = incoming.updatedAt > foo.updatedAt ? incoming.tags : foo.tags;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "foo.tags = orSet.merge(foo.tags, incoming.tags);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "replication design review", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Commutative Merge](/records/lexicon/commutative-merge), [Eventual Consistency](/records/architecture/eventual-consistency), [Causal Consistency](/records/architecture/causal-consistency), [Conflict-Free Replica Convergence](/records/lexicon/conflict-free-replica-convergence)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-crdts", "title": "CRDTs" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: event, distributed state, ordering", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that delivers every message to every node in the same order, agreed by consensus.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Consensus](/records/architecture/consensus)", "term": "Requires" }, { "description": "[Event Ordering](/records/architecture/event-ordering), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Identical Delivery Order Across Nodes](/records/lexicon/identical-delivery-order-across-nodes)", "term": "Enables" }, { "description": "[Latency](/records/architecture/latency)", "term": "In tension with" }, { "description": "[Per-Node Independent Ordering](/records/lexicon/per-node-independent-ordering)", "term": "Conflicts with" }, { "description": "[Total-Order Broadcast / Latency](/records/tension/latency-total-order-broadcast)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Per-Node Independent Ordering](/records/lexicon/per-node-independent-ordering)", "term": "Violated by" }, { "description": "state divergence across nodes given same events", "term": "Detected by" }, { "description": "cross-node order divergence rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "replica.apply(event);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const sequenced = await totalOrder.broadcast(event);\nreplica.applyInOrder(sequenced.sequence, sequenced.event);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Consensus](/records/architecture/consensus), [Event Ordering](/records/architecture/event-ordering), [Consistency](/records/architecture/consistency), [Identical Delivery Order Across Nodes](/records/lexicon/identical-delivery-order-across-nodes)", "term": "Depends on" }, { "description": "[Per-Node Independent Ordering](/records/lexicon/per-node-independent-ordering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-total-order-broadcast", "title": "Total-Order Broadcast" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: distributed state, consistency, availability", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the choice a distributed store makes during a network partition, between consistency and availability.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Network Partition Possibility](/records/lexicon/network-partition-possibility)", "term": "Requires" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency), [Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Reinforces" }, { "description": "[Explicit Consistency/Availability Choice Under Partition](/records/lexicon/explicit-consistency-availability-choice-under-partition)", "term": "Enables" }, { "description": "[Latency](/records/architecture/latency)", "term": "In tension with" }, { "description": "[Assumed Total Consistency And Availability](/records/lexicon/assumed-total-consistency-and-availability)", "term": "Conflicts with" }, { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem)", "term": "Referenced by" }, { "description": "[CAP Theorem / Latency](/records/tension/cap-theorem-latency)", "term": "Tensions" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency): The CAP theorem states the trade-off a store makes during a partition, while causal consistency is one guarantee a store can offer.", "term": "Distinct from" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency): The CAP theorem is the trade-off, while eventual consistency is the guarantee an available store settles for.", "term": "Distinct from" }, { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem): The CAP theorem covers only a partition, while PACELC adds the latency and consistency trade-off of a healthy network.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Assumed Total Consistency And Availability](/records/lexicon/assumed-total-consistency-and-availability)", "term": "Violated by" }, { "description": "split-brain writes or stalls during network partitions", "term": "Detected by" }, { "description": "consistency/availability violations during partition events", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await Promise.all(replicas.map(r => r.write(foo)));\nreturn \"always consistent and available\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const policy = partitionPolicyFor(foo.class);\nreturn policy === \"CP\"\n ? writeWithQuorum(foo)\n : writeAvailableAndReconcile(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[Network Partition Possibility](/records/lexicon/network-partition-possibility), [Causal Consistency](/records/architecture/causal-consistency), [Eventual Consistency](/records/architecture/eventual-consistency), [Explicit Consistency/Availability Choice Under Partition](/records/lexicon/explicit-consistency-availability-choice-under-partition)", "term": "Depends on" }, { "description": "[Assumed Total Consistency And Availability](/records/lexicon/assumed-total-consistency-and-availability)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-cap-theorem", "title": "CAP Theorem" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/architecture-category/causality-ordering-distributed-time)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed state, consistency, latency", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation that extends the CAP theorem with the trade-off a healthy network still forces, between latency and consistency.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Requires" }, { "description": "[CAP Theorem](/records/architecture/cap-theorem), [Latency](/records/architecture/latency)", "term": "Reinforces" }, { "description": "[Latency-Consistency Trade-off When Healthy](/records/lexicon/latency-consistency-trade-off-when-healthy)", "term": "Enables" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "In tension with" }, { "description": "[Consistency Assumed Free When Healthy](/records/lexicon/consistency-assumed-free-when-healthy)", "term": "Conflicts with" }, { "description": "[PACELC Theorem / Throughput](/records/tension/pacelc-theorem-throughput)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Consistency Assumed Free When Healthy](/records/lexicon/consistency-assumed-free-when-healthy)", "term": "Violated by" }, { "description": "tail latency driven by synchronous cross-region consistency during normal operation", "term": "Detected by" }, { "description": "latency-vs-staleness tradeoff per read class", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await readFromAllRegionsStrongly(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = tolerateStaleness(id.class)\n ? await readLocalReplica(id)\n : await readStronglyAcrossRegions(id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every event, replica update and dependency edge whose order affects the result", "term": "Population" }, { "description": "A verdict stands until the event schema, the ordering key or the replication protocol changes", "term": "Freshness" }, { "description": "The ordering or consistency test fails, or the graph check rejects the edge that breaks the order", "term": "Refusal" }, { "description": "Causation metadata on events, ordering-anomaly counts from tests, and the extracted dependency graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The ordering key and the replication protocol, which every event and replica update conforms to", "term": "Authoritative side" }, { "description": "[CAP Theorem](/records/architecture/cap-theorem), [CAP Theorem](/records/architecture/cap-theorem), [Latency](/records/architecture/latency), [Latency-Consistency Trade-off When Healthy](/records/lexicon/latency-consistency-trade-off-when-healthy)", "term": "Depends on" }, { "description": "[Consistency Assumed Free When Healthy](/records/lexicon/consistency-assumed-free-when-healthy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pacelc-theorem", "title": "PACELC Theorem" } ], "title": "Causality / Ordering / Distributed Time" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_design_by_contract[\"Design by Contract\"]\n n_explicit_contracts[\"Explicit Contracts\"]\n n_stable_interfaces[\"Stable Interfaces\"]\n n_interface_based_design[\"Interface-Based Design\"]\n n_contract_first_design[\"Contract-First Design\"]\n n_api_contract[\"API Contract\"]\n n_service_contract[\"Service Contract\"]\n n_data_contract[\"Data Contract\"]\n n_schema_contract[\"Schema Contract\"]\n n_semantic_contracts[\"Semantic Contracts\"]\n n_preconditions[\"Preconditions\"]\n n_postconditions[\"Postconditions\"]\n n_invariant[\"Invariant\"]\n n_backward_compatibility[\"Backward Compatibility\"]\n n_forward_compatibility[\"Forward Compatibility\"]\n n_versioning[\"Versioning\"]\n n_protocol_compatibility[\"Protocol Compatibility\"]\n n_interoperability[\"Interoperability\"]\n n_uniform_interface[\"Uniform Interface\"]\n n_consumer_driven_contracts[\"Consumer-Driven Contracts\"]\n n_design_by_contract --> n_preconditions\n n_design_by_contract --> n_postconditions\n n_design_by_contract --> n_invariant\n n_explicit_contracts --> n_stable_interfaces\n n_explicit_contracts --> n_interoperability\n n_explicit_contracts --> n_contract_first_design\n n_stable_interfaces --> n_versioning\n n_stable_interfaces --> n_backward_compatibility\n n_interface_based_design --> n_stable_interfaces\n n_contract_first_design --> n_explicit_contracts\n n_contract_first_design --> n_schema_contract\n n_contract_first_design --> n_interoperability\n n_contract_first_design --> n_backward_compatibility\n n_api_contract --> n_versioning\n n_api_contract --> n_stable_interfaces\n n_api_contract --> n_interoperability\n n_service_contract --> n_api_contract\n n_data_contract --> n_interoperability\n n_schema_contract --> n_data_contract\n n_preconditions --> n_design_by_contract\n n_postconditions --> n_invariant\n n_backward_compatibility --> n_versioning\n n_backward_compatibility --> n_stable_interfaces\n n_versioning --> n_stable_interfaces\n n_versioning --> n_backward_compatibility\n n_protocol_compatibility --> n_versioning\n n_protocol_compatibility --> n_interoperability\n n_consumer_driven_contracts --> n_explicit_contracts\n n_consumer_driven_contracts --> n_backward_compatibility\n n_consumer_driven_contracts --> n_contract_first_design" } ], "icon": "bi-collection", "id": "architecture-category-contracts-interfaces-compatibility", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, function, class, service", "Aliases: DbC", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every operation states the preconditions it needs, the postconditions it guarantees and the invariants it keeps.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Preconditions](/records/architecture/preconditions), [Postconditions](/records/architecture/postconditions), [Invariant](/records/architecture/invariant)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Contract Testing](/records/lexicon/contract-testing), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Enables" }, { "description": "[Development Speed](/records/lexicon/development-speed)", "term": "In tension with" }, { "description": "[Implicit Behavior](/records/lexicon/implicit-behavior)", "term": "Conflicts with" }, { "description": "[Preconditions](/records/architecture/preconditions), [Correctness](/records/architecture/correctness)", "term": "Referenced by" }, { "description": "[Architectural Contract Algebra](/records/algorithms/architectural-contract-algebra), [Contract-Based Verification Kernel](/records/algorithms/contract-based-verification-kernel)", "term": "Contracts" }, { "description": "[Design by Contract / Development Speed](/records/tension/design-by-contract-development-speed)", "term": "Tensions" }, { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution): Design by contract states each operation's conditions, while Liskov substitution requires a subtype to keep the conditions of its base type.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implicit Assumptions](/records/lexicon/implicit-assumptions), [Trusting Invalid Inputs](/records/lexicon/trusting-invalid-inputs)", "term": "Violated by" }, { "description": "missing assertions, missing validation, vague public APIs", "term": "Detected by" }, { "description": "contract coverage", "term": "Measured by" }, { "description": "[Precondition Check](/records/lexicon/precondition-check), [Postcondition Check](/records/lexicon/postcondition-check), [Invariant Check](/records/lexicon/invariant-check)", "term": "Refactored by" }, { "description": "assertions, contract tests, [static analysis](/records/reasoning/technique-static-analysis)", "term": "Enforced by" }, { "description": "design-by-contract", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function divideFoo(total: number, count: number) {\n return total / count;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function divideFoo(total: number, count: number): number {\n if (!Number.isFinite(total)) throw new Error(\"pre: total must be finite\");\n if (!Number.isInteger(count) || count <= 0) throw new Error(\"pre: count must be positive\");\n const result = total / count;\n if (!Number.isFinite(result)) throw new Error(\"post: result must be finite\");\n return result;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "assertions, contract tests, static analysis", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Preconditions](/records/architecture/preconditions), [Postconditions](/records/architecture/postconditions), [Invariant](/records/architecture/invariant), [Correctness](/records/architecture/correctness), [Predictability](/records/architecture/predictability), [Contract Testing](/records/lexicon/contract-testing), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Depends on" }, { "description": "[Implicit Behavior](/records/lexicon/implicit-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-design-by-contract", "title": "Design by Contract" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, service, data, protocol", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every boundary declares the shape and meaning of what crosses it in a typed contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Type Safety](/records/architecture/type-safety)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Contract-First Design](/records/architecture/contract-first-design)", "term": "Enables" }, { "description": "[Rapid Prototyping](/records/lexicon/rapid-prototyping)", "term": "In tension with" }, { "description": "[Implicit Contract](/records/architecture/implicit-contract)", "term": "Conflicts with" }, { "description": "[Contract-First Design](/records/architecture/contract-first-design), [Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts), [Predictability](/records/architecture/predictability), [Autonomy](/records/architecture/autonomy)", "term": "Referenced by" }, { "description": "[Contracts Core](/records/algorithms/contracts-core), [PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Contracts" }, { "description": "[Explicit Contracts / Rapid Prototyping](/records/tension/explicit-contracts-rapid-prototyping)", "term": "Tensions" }, { "description": "[Determinism](/records/architecture/determinism): Explicit contracts declare what crosses a boundary, while determinism makes the same inputs give the same result.", "term": "Distinct from" }, { "description": "[Contract-First Design](/records/architecture/contract-first-design): Explicit contracts require a declared contract, while contract-first design fixes when it is written, before the implementation.", "term": "Distinct from" }, { "description": "[Independence](/records/architecture/independence): Explicit contracts declare boundaries, while independence lets a module be tested and deployed without its neighbors.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Dynamic Untyped Boundaries](/records/lexicon/dynamic-untyped-boundaries), [Untyped Payloads](/records/lexicon/untyped-payloads)", "term": "Violated by" }, { "description": "public methods without DTO/schema, dynamic maps at boundaries", "term": "Detected by" }, { "description": "boundary contract coverage", "term": "Measured by" }, { "description": "[Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto), [Schema Validation](/records/architecture/schema-validation), [Extract Interface](/records/lexicon/extract-interface)", "term": "Refactored by" }, { "description": "[schema validation](/records/architecture/schema-validation), API linting", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: any): any { return fooStore.save(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface SaveFoo {\n execute(input: Readonly<{ id: FooId; name: string }>): Promise<{ saved: true; version: number }>;\n}\nconst saveFoo: SaveFoo = { execute: input => fooStore.save(input) };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema validation, API linting", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Type Safety](/records/architecture/type-safety), [Predictability](/records/architecture/predictability), [Interoperability](/records/architecture/interoperability), [Contract-First Design](/records/architecture/contract-first-design)", "term": "Depends on" }, { "description": "[Implicit Contract](/records/architecture/implicit-contract), [Implicit Contract](/records/architecture/implicit-contract)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-explicit-contracts", "title": "Explicit Contracts" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, module, service", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a public interface keeps its signatures and meaning across releases.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Versioning](/records/architecture/versioning), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Independent Consumers](/records/lexicon/independent-consumers)", "term": "Enables" }, { "description": "[Evolution Speed](/records/lexicon/evolution-speed)", "term": "In tension with" }, { "description": "[Breaking Change](/records/lexicon/breaking-change)", "term": "Conflicts with" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Explicit Contracts](/records/architecture/explicit-contracts), [Interface-Based Design](/records/architecture/interface-based-design), [API Contract](/records/architecture/api-contract), [Backward Compatibility](/records/architecture/backward-compatibility), [Versioning](/records/architecture/versioning), [Low Coupling](/records/architecture/low-coupling), [Encapsulation](/records/architecture/encapsulation), [Composability](/records/architecture/composability), [Replaceability](/records/architecture/replaceability), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Plugin Architecture](/records/architecture/plugin-architecture), [Extension Points](/records/architecture/extension-points), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Referenced by" }, { "description": "[Stable Interfaces / Evolution Speed](/records/tension/evolution-speed-stable-interfaces)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change), [Schema Drift](/records/architecture/schema-drift)", "term": "Violated by" }, { "description": "incompatible API diffs", "term": "Detected by" }, { "description": "breaking-change frequency", "term": "Measured by" }, { "description": "[Versioning](/records/architecture/versioning), [Extract Adapter](/records/lexicon/extract-adapter), [Gradual Deprecation](/records/lexicon/gradual-deprecation)", "term": "Refactored by" }, { "description": "API diff checks, contract tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n createFoo(name: string, tags: string[], notify: boolean, source: string) {}\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type CreateFooRequest = Readonly<{\n name: string;\n tags: readonly string[];\n extensions: Readonly>;\n}>;\ninterface FooService { create(request: CreateFooRequest): Promise; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API diff checks, contract tests", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Versioning](/records/architecture/versioning), [Backward Compatibility](/records/architecture/backward-compatibility), [Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability), [Independent Consumers](/records/lexicon/independent-consumers)", "term": "Depends on" }, { "description": "[Breaking Change](/records/lexicon/breaking-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-stable-interfaces", "title": "Stable Interfaces" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: class, module, service", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a module depends on interfaces, and the implementation behind each one is supplied from outside.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Enables" }, { "description": "[Interface Overuse](/records/lexicon/interface-overuse)", "term": "In tension with" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Conflicts with" }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Referenced by" }, { "description": "[Interface-Based Design / Interface Overuse](/records/tension/interface-based-design-interface-overuse)", "term": "Tensions" }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance): Interface-based design depends on interfaces, while composition over inheritance reuses behavior by holding objects rather than extending classes.", "term": "Distinct from" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion): Interface-based design depends on interfaces supplied from outside, while dependency inversion also fixes that the policy side owns the interface.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Violated by" }, { "description": "concrete constructor dependencies", "term": "Detected by" }, { "description": "interface-to-implementation boundary ratio", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "dependency rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(store: SqlFooStore, foo: Foo) { return store.insert(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooWriter { save(foo: Foo): Promise; }\nfunction processFoo(store: FooWriter, foo: Foo) { return store.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency rules", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability), [Dependency Injection](/records/architecture/dependency-injection), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Depends on" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-interface-based-design", "title": "Interface-Based Design" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, service, integration", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a boundary's contract is written and agreed before the implementation behind it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Schema Contract](/records/architecture/schema-contract)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Reinforces" }, { "description": "[Consumer-Driven Development](/records/lexicon/consumer-driven-development)", "term": "Enables" }, { "description": "[Iteration Speed](/records/lexicon/iteration-speed)", "term": "In tension with" }, { "description": "[Implementation-First Integration](/records/lexicon/implementation-first-integration)", "term": "Conflicts with" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Referenced by" }, { "description": "[Contract-First Design / Iteration Speed](/records/tension/contract-first-design-iteration-speed)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implementation-First Integration](/records/lexicon/implementation-first-integration)", "term": "Violated by" }, { "description": "absent contract before implementation", "term": "Detected by" }, { "description": "contract-first coverage", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract), [Code Generation](/records/lexicon/code-generation), [Contract Testing](/records/lexicon/contract-testing)", "term": "Refactored by" }, { "description": "CI contract gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo\", async request => fooStore.save(await request.json()));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type CreateFooRequest = { name: string };\ntype CreateFooResponse = { id: FooId; version: 1 };\ninterface CreateFooContract {\n request: CreateFooRequest;\n response: CreateFooResponse;\n}\napp.post(\"/foo\", implement(createFoo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI contract gates", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Schema Contract](/records/architecture/schema-contract), [Interoperability](/records/architecture/interoperability), [Backward Compatibility](/records/architecture/backward-compatibility), [Consumer-Driven Development](/records/lexicon/consumer-driven-development)", "term": "Depends on" }, { "description": "[Implementation-First Integration](/records/lexicon/implementation-first-integration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-contract-first-design", "title": "Contract-First Design" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, service boundary", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that each endpoint declares its request, response and error shapes in a versioned schema.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Schema](/records/lexicon/schema), [Versioning](/records/architecture/versioning), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Client Compatibility](/records/lexicon/client-compatibility)", "term": "Enables" }, { "description": "[Evolution](/records/lexicon/evolution)", "term": "In tension with" }, { "description": "[Breaking API Change](/records/lexicon/breaking-api-change)", "term": "Conflicts with" }, { "description": "[Service Contract](/records/architecture/service-contract), [Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" }, { "description": "[API Contract / Evolution](/records/tension/api-contract-evolution)", "term": "Tensions" }, { "description": "[Semantic Contract](/records/lexicon/semantic-contract): An API contract declares the shapes of requests, responses and errors, while a semantic contract declares what the operations mean.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Endpoints](/records/lexicon/ad-hoc-endpoints), [Inconsistent Error Model](/records/architecture/inconsistent-error-model)", "term": "Violated by" }, { "description": "OpenAPI drift, missing endpoint schemas", "term": "Detected by" }, { "description": "contract coverage, breaking diff count", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract), [Standard Error Contract](/records/lexicon/standard-error-contract), [Versioning](/records/architecture/versioning)", "term": "Refactored by" }, { "description": "OpenAPI linting, contract tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/foo/:id\", async request => fooStore.find(request.params.id));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const getFooApi = endpoint({\n method: \"GET\",\n path: \"/v1/foo/{id}\",\n request: FooIdSchema,\n response: FooResponseSchema,\n errors: [\"FOO_NOT_FOUND\"] as const,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "OpenAPI linting, contract tests", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Schema](/records/lexicon/schema), [Versioning](/records/architecture/versioning), [Stable Interfaces](/records/architecture/stable-interfaces), [Interoperability](/records/architecture/interoperability), [Predictability](/records/architecture/predictability), [Client Compatibility](/records/lexicon/client-compatibility)", "term": "Depends on" }, { "description": "[Breaking API Change](/records/lexicon/breaking-api-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-api-contract", "title": "API Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: service, integration", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a service declares its operations, their results and their side effects to every consumer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract), [Semantic Contract](/records/lexicon/semantic-contract)", "term": "Requires" }, { "description": "[Autonomy](/records/architecture/autonomy), [Compatibility](/records/lexicon/compatibility)", "term": "Reinforces" }, { "description": "[Independent Deployment](/records/lexicon/independent-deployment)", "term": "Enables" }, { "description": "[Distributed Evolution](/records/lexicon/distributed-evolution)", "term": "In tension with" }, { "description": "[Hidden Service Coupling](/records/lexicon/hidden-service-coupling)", "term": "Conflicts with" }, { "description": "[Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" }, { "description": "[Service Contract / Distributed Evolution](/records/tension/distributed-evolution-service-contract)", "term": "Tensions" }, { "description": "[API Contract](/records/architecture/api-contract): A service contract declares a service's operations, results and side effects, while an API contract declares the shapes at each endpoint.", "term": "Distinct from" }, { "description": "[Semantic Contract](/records/lexicon/semantic-contract): A service contract covers one service's whole surface, while a semantic contract is the meaning part of any interface's contract.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Service Coupling](/records/lexicon/hidden-service-coupling), [Silent Breaking Changes](/records/lexicon/silent-breaking-changes)", "term": "Violated by" }, { "description": "consumer failures after service changes", "term": "Detected by" }, { "description": "consumer contract pass rate", "term": "Measured by" }, { "description": "[Consumer-Driven Contract Tests](/records/lexicon/consumer-driven-contract-tests), [Service Level Objectives](/records/lexicon/service-level-objectives), [Versioning](/records/architecture/versioning)", "term": "Refactored by" }, { "description": "contract tests, deployment gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooClient {\n create(body: any) { return http.post(\"/foo\", body); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooServiceContract {\n create(input: CreateFoo): Promise>;\n}\nclass FooClient implements FooServiceContract {\n create(input: CreateFoo) { return transport.call(\"Foo.Create\", input); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, deployment gates", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[API Contract](/records/architecture/api-contract), [Semantic Contract](/records/lexicon/semantic-contract), [Autonomy](/records/architecture/autonomy), [Compatibility](/records/lexicon/compatibility), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Depends on" }, { "description": "[Hidden Service Coupling](/records/lexicon/hidden-service-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-service-contract", "title": "Service Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: data, message, persistence, integration", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that data exchanged between parties has declared fields, types, nullability and meaning.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Schema](/records/lexicon/schema), [Type Safety](/records/architecture/type-safety), [Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability), [Data Quality](/records/lexicon/data-quality)", "term": "Reinforces" }, { "description": "[Schema Evolution](/records/lexicon/schema-evolution)", "term": "Enables" }, { "description": "[Flexible Ingestion](/records/lexicon/flexible-ingestion)", "term": "In tension with" }, { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Conflicts with" }, { "description": "[Schema Contract](/records/architecture/schema-contract), [Schema Validation](/records/architecture/schema-validation), [Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" }, { "description": "[Data Contract / Flexible Ingestion](/records/tension/data-contract-flexible-ingestion)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Untyped Payloads](/records/lexicon/untyped-payloads), [Null Semantics Drift](/records/architecture/null-semantics-drift)", "term": "Violated by" }, { "description": "data validation failures, schema mismatch", "term": "Detected by" }, { "description": "schema conformance rate", "term": "Measured by" }, { "description": "[Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto), [Schema Validation](/records/architecture/schema-validation), [Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Refactored by" }, { "description": "[schema registry](/records/lexicon/schema-registry), validation gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type FooMessage = Record;\nqueue.publish(\"foo\", payload);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooMessageV1 = Readonly<{\n type: \"FooCreated\";\n version: 1;\n fooId: FooId;\n name: string;\n}>;\nqueue.publish(\"foo.created.v1\", message);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema registry, validation gates", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Schema](/records/lexicon/schema), [Type Safety](/records/architecture/type-safety), [Semantic Consistency](/records/architecture/semantic-consistency), [Interoperability](/records/architecture/interoperability), [Data Quality](/records/lexicon/data-quality), [Schema Evolution](/records/lexicon/schema-evolution)", "term": "Depends on" }, { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-data-contract", "title": "Data Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: data, API, message", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that every payload is validated against a machine-readable schema at the boundary it crosses.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Canonical Schema](/records/architecture/canonical-schema), [Schema Validation](/records/architecture/schema-validation)", "term": "Requires" }, { "description": "[Data Contract](/records/architecture/data-contract), [Compatibility](/records/lexicon/compatibility)", "term": "Reinforces" }, { "description": "[Automated Validation](/records/lexicon/automated-validation)", "term": "Enables" }, { "description": "[Schema Flexibility](/records/lexicon/schema-flexibility)", "term": "In tension with" }, { "description": "[Ad-Hoc Payloads](/records/lexicon/ad-hoc-payloads)", "term": "Conflicts with" }, { "description": "[Contract-First Design](/records/architecture/contract-first-design), [Schema Validation](/records/architecture/schema-validation), [Canonical Schema](/records/architecture/canonical-schema)", "term": "Referenced by" }, { "description": "[Schema Contract / Schema Flexibility](/records/tension/schema-contract-schema-flexibility)", "term": "Tensions" }, { "description": "[Data Contract](/records/architecture/data-contract): A data contract declares the fields, types and meaning of exchanged data, while a schema contract validates each payload against a schema at the boundary.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Payloads](/records/lexicon/ad-hoc-payloads), [Schema Drift](/records/architecture/schema-drift)", "term": "Violated by" }, { "description": "schema diff failures", "term": "Detected by" }, { "description": "schema validation coverage", "term": "Measured by" }, { "description": "[Schema Validation](/records/architecture/schema-validation), [Binary Schema Encoding](/records/lexicon/binary-schema-encoding), [Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "[schema registry](/records/lexicon/schema-registry), CI schema checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = JSON.parse(raw) as Foo;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FooSchema = object({ id: string(), count: integer() });\nconst foo: Foo = FooSchema.parse(JSON.parse(raw));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema registry, CI schema checks", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Canonical Schema](/records/architecture/canonical-schema), [Schema Validation](/records/architecture/schema-validation), [Data Contract](/records/architecture/data-contract), [Compatibility](/records/lexicon/compatibility), [Automated Validation](/records/lexicon/automated-validation)", "term": "Depends on" }, { "description": "[Ad-Hoc Payloads](/records/lexicon/ad-hoc-payloads)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-schema-contract", "title": "Schema Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: domain, API, data", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that each term and value at a boundary has one agreed meaning, beyond its type.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Domain Model](/records/architecture/domain-model)", "term": "Requires" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Reliable Integration](/records/lexicon/reliable-integration)", "term": "Enables" }, { "description": "[Cross-Domain Translation](/records/lexicon/cross-domain-translation)", "term": "In tension with" }, { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming)", "term": "Conflicts with" }, { "description": "[Domain Model](/records/architecture/domain-model), [Semantic Consistency](/records/architecture/semantic-consistency), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Referenced by" }, { "description": "[Semantic Contracts / Cross-Domain Translation](/records/tension/cross-domain-translation-semantic-contracts)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming)", "term": "Violated by" }, { "description": "conflicting field meanings, overloaded names", "term": "Detected by" }, { "description": "semantic conflict count", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept), [Split Bounded Context](/records/lexicon/split-bounded-context), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Refactored by" }, { "description": "domain glossary, contract review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function reserveFoo(count: number) { return fooStore.decrement(count); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type PositiveCount = number & { readonly __brand: \"PositiveCount\" };\nfunction reserveFoo(count: PositiveCount): Promise<{ reserved: true }> {\n return fooInventory.reserveExactly(count);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain glossary, contract review", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Domain Model](/records/architecture/domain-model), [Semantic Consistency](/records/architecture/semantic-consistency), [Correctness](/records/architecture/correctness), [Reliable Integration](/records/lexicon/reliable-integration)", "term": "Depends on" }, { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-semantic-contracts", "title": "Semantic Contracts" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, method, API", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that must hold on an operation's input and state before the operation runs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Input Validation](/records/architecture/input-validation)", "term": "Requires" }, { "description": "[Design by Contract](/records/architecture/design-by-contract), [Fail Fast](/records/architecture/fail-fast)", "term": "Reinforces" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Enables" }, { "description": "[Permissive APIs](/records/lexicon/permissive-apis)", "term": "In tension with" }, { "description": "[Implicit Assumptions](/records/lexicon/implicit-assumptions)", "term": "Conflicts with" }, { "description": "[Design by Contract](/records/architecture/design-by-contract), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Fail Fast](/records/architecture/fail-fast)", "term": "Referenced by" }, { "description": "[Preconditions / Permissive APIs](/records/tension/permissive-apis-preconditions)", "term": "Tensions" }, { "description": "[Invariant](/records/architecture/invariant): A precondition holds before one operation runs, while an invariant holds in every reachable state.", "term": "Distinct from" }, { "description": "[Postconditions](/records/architecture/postconditions): A precondition is checked before an operation runs, while a postcondition is guaranteed when it returns.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Trusting Invalid Inputs](/records/lexicon/trusting-invalid-inputs)", "term": "Violated by" }, { "description": "missing validation before state transition", "term": "Detected by" }, { "description": "invalid-input handling coverage", "term": "Measured by" }, { "description": "[Precondition Check](/records/lexicon/precondition-check), [Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "[validation rules](/records/lexicon/validation-rules), [static analysis](/records/reasoning/technique-static-analysis)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renameFoo(foo: Foo, name: string) { foo.name = name; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function renameFoo(foo: Foo, name: string) {\n if (foo.status !== \"active\") throw new Error(\"pre: Foo must be active\");\n if (name.trim().length === 0) throw new Error(\"pre: name required\");\n foo.rename(name.trim());\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "validation rules, static analysis", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Input Validation](/records/architecture/input-validation), [Design by Contract](/records/architecture/design-by-contract), [Fail Fast](/records/architecture/fail-fast), [Correctness](/records/architecture/correctness)", "term": "Depends on" }, { "description": "[Implicit Assumptions](/records/lexicon/implicit-assumptions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-preconditions", "title": "Preconditions" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, method, transaction", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that an operation's result and resulting state must satisfy when it returns.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Result Validation](/records/lexicon/result-validation), [Invariant](/records/architecture/invariant)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Testability](/records/architecture/testability)", "term": "Enables" }, { "description": "[Runtime Cost](/records/lexicon/runtime-cost)", "term": "In tension with" }, { "description": "[Undefined Results](/records/lexicon/undefined-results)", "term": "Conflicts with" }, { "description": "[Design by Contract](/records/architecture/design-by-contract), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Referenced by" }, { "description": "[Postconditions / Runtime Cost](/records/tension/postconditions-runtime-cost)", "term": "Tensions" }, { "description": "[Invariant](/records/architecture/invariant): A postcondition holds when one operation returns, while an invariant holds in every state an entity can reach.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Undefined Results](/records/lexicon/undefined-results)", "term": "Violated by" }, { "description": "missing assertions on results", "term": "Detected by" }, { "description": "property test coverage", "term": "Measured by" }, { "description": "[Invariant Check](/records/lexicon/invariant-check), [Introduce Typed Result](/records/lexicon/introduce-typed-result), [Contract Testing](/records/lexicon/contract-testing)", "term": "Refactored by" }, { "description": "property tests, invariant checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function createFoo(foo: Foo) { return fooStore.save(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function createFoo(foo: Foo): Promise {\n await fooStore.save(foo);\n const saved = await fooStore.find(foo.id);\n if (!saved) throw new Error(\"post: Foo must be persisted\");\n return saved.id;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "property tests, invariant checks", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Result Validation](/records/lexicon/result-validation), [Invariant](/records/architecture/invariant), [Correctness](/records/architecture/correctness), [Predictability](/records/architecture/predictability), [Testability](/records/architecture/testability)", "term": "Depends on" }, { "description": "[Undefined Results](/records/lexicon/undefined-results)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-postconditions", "title": "Postconditions" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: entity, aggregate, module, system", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that holds for an entity or aggregate in every state it can reach.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation), [Validation](/records/architecture/validation)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Safe Refactoring](/records/lexicon/safe-refactoring)", "term": "Enables" }, { "description": "[Flexibility](/records/lexicon/flexibility)", "term": "In tension with" }, { "description": "[External State Mutation](/records/lexicon/external-state-mutation)", "term": "Conflicts with" }, { "description": "[Domain Model](/records/architecture/domain-model), [Aggregate](/records/architecture/aggregate), [Design by Contract](/records/architecture/design-by-contract), [Postconditions](/records/architecture/postconditions), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Consistency](/records/architecture/consistency)", "term": "Referenced by" }, { "description": "[Invariant / Flexibility](/records/tension/flexibility-invariant)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Reachable Invalid State](/records/lexicon/reachable-invalid-state)", "term": "Violated by" }, { "description": "mutable public state, missing invariant checks", "term": "Detected by" }, { "description": "invariant test coverage", "term": "Measured by" }, { "description": "[Encapsulate State](/records/lexicon/encapsulate-state), [Factory Pattern](/records/architecture/factory-pattern), [Validate at the Boundary](/records/lexicon/validate-at-the-boundary)", "term": "Refactored by" }, { "description": "domain tests, constructors, type system", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooAccount {\n balance = 0;\n withdraw(amount: number) { this.balance -= amount; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooAccount {\n #balance = 0;\n withdraw(amount: number) {\n if (amount <= 0 || amount > this.#balance) throw new Error(\"invariant: balance >= 0\");\n this.#balance -= amount;\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain tests, constructors, type system", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Validation](/records/architecture/validation), [Correctness](/records/architecture/correctness), [Consistency](/records/architecture/consistency), [Safe Refactoring](/records/lexicon/safe-refactoring)", "term": "Depends on" }, { "description": "[External State Mutation](/records/lexicon/external-state-mutation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-invariant", "title": "Invariant" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, schema, protocol", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a new version keeps working for consumers written against an older one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Versioning](/records/architecture/versioning), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Consumer Safety](/records/lexicon/consumer-safety)", "term": "Reinforces" }, { "description": "[Incremental Deployment](/records/lexicon/incremental-deployment)", "term": "Enables" }, { "description": "[Cleanup / Simplification](/records/lexicon/cleanup-simplification)", "term": "In tension with" }, { "description": "[Breaking Change](/records/lexicon/breaking-change)", "term": "Conflicts with" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Contract-First Design](/records/architecture/contract-first-design), [Versioning](/records/architecture/versioning), [Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts), [Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Backward Compatibility / Cleanup / Simplification](/records/tension/backward-compatibility-cleanup-simplification)", "term": "Tensions" }, { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts): Backward compatibility is the property a new version keeps, while consumer-driven contracts are how a provider verifies it against recorded expectations.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Breaking Change](/records/lexicon/breaking-change)", "term": "Violated by" }, { "description": "API/schema diff", "term": "Detected by" }, { "description": "breaking-change count", "term": "Measured by" }, { "description": "[Versioning](/records/architecture/versioning), [Gradual Deprecation](/records/lexicon/gradual-deprecation), [Extract Adapter](/records/lexicon/extract-adapter)", "term": "Refactored by" }, { "description": "compatibility tests, API diff gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/foo\", () => ({ label: \"Foo\", tags: [] }));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.get(\"/v1/foo\", () => ({ name: \"Foo\" }));\napp.get(\"/v2/foo\", () => ({ label: \"Foo\", tags: [] }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compatibility tests, API diff gates", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Versioning](/records/architecture/versioning), [Stable Interfaces](/records/architecture/stable-interfaces), [Consumer Safety](/records/lexicon/consumer-safety), [Incremental Deployment](/records/lexicon/incremental-deployment)", "term": "Depends on" }, { "description": "[Breaking Change](/records/lexicon/breaking-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-backward-compatibility", "title": "Backward Compatibility" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, schema, protocol", "Aliases: Unknown Field Handling", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that an older reader accepts data from a newer writer by ignoring the fields it does not know rather than failing on them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Extensible Schema](/records/lexicon/extensible-schema)", "term": "Requires" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Reinforces" }, { "description": "[Rolling Upgrades](/records/lexicon/rolling-upgrades)", "term": "Enables" }, { "description": "[Strong Validation](/records/lexicon/strong-validation)", "term": "In tension with" }, { "description": "[Strict Fragile Parsers](/records/lexicon/strict-fragile-parsers)", "term": "Conflicts with" }, { "description": "[Forward Compatibility / Strong Validation](/records/tension/forward-compatibility-strong-validation)", "term": "Tensions" }, { "description": "[Extensible Schema](/records/lexicon/extensible-schema): Forward compatibility is the reader tolerating unknown fields, while an extensible schema is the writer's shape that lets fields be added.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Strict Fragile Parsers](/records/lexicon/strict-fragile-parsers)", "term": "Violated by" }, { "description": "parser failures on additive changes", "term": "Detected by" }, { "description": "forward-compatibility test pass rate", "term": "Measured by" }, { "description": "[Extension Points](/records/architecture/extension-points), [Tolerant Reader](/records/lexicon/tolerant-reader)", "term": "Refactored by" }, { "description": "compatibility test matrix", "term": "Enforced by" }, { "description": "forward-compatibility", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function readFoo(input: { name: string }) {\n if (Object.keys(input).length !== 1) throw new Error(\"unknown field\");\n return input.name;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooEnvelope = { name: string; extensions?: Record };\nfunction readFoo(input: FooEnvelope) {\n return { name: input.name, extensions: input.extensions ?? {} };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compatibility test matrix", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Extensible Schema](/records/lexicon/extensible-schema), [Evolutionary Architecture](/records/architecture/evolutionary-architecture), [Rolling Upgrades](/records/lexicon/rolling-upgrades)", "term": "Depends on" }, { "description": "[Strict Fragile Parsers](/records/lexicon/strict-fragile-parsers)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-forward-compatibility", "title": "Forward Compatibility" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, schema, package, service", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that labels each release of an interface or schema, so consumers can tell compatible changes from breaking ones.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Compatibility Policy](/records/lexicon/compatibility-policy)", "term": "Requires" }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility), [Governance](/records/architecture/governance)", "term": "Reinforces" }, { "description": "[Controlled Evolution](/records/lexicon/controlled-evolution)", "term": "Enables" }, { "description": "[Version Sprawl](/records/lexicon/version-sprawl)", "term": "In tension with" }, { "description": "[Silent Breaking Changes](/records/lexicon/silent-breaking-changes)", "term": "Conflicts with" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [API Contract](/records/architecture/api-contract), [Backward Compatibility](/records/architecture/backward-compatibility), [Protocol Compatibility](/records/architecture/protocol-compatibility), [Integration Events](/records/architecture/integration-events)", "term": "Referenced by" }, { "description": "[Versioned Evolution Over Breaking Change](/records/algorithms/no-breaking-change), [Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Contracts" }, { "description": "[Versioning / Version Sprawl](/records/tension/version-sprawl-versioning)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Violated by" }, { "description": "incompatible diff without version bump", "term": "Detected by" }, { "description": "version compliance, deprecation window", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "release gates, API checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "queue.publish(\"foo.created\", { id: foo.id, name: foo.name });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "queue.publish(\"foo.created.v2\", {\n schemaVersion: 2,\n id: foo.id,\n label: foo.name,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "release gates, API checks", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Compatibility Policy](/records/lexicon/compatibility-policy), [Backward Compatibility](/records/architecture/backward-compatibility), [Governance](/records/architecture/governance), [Controlled Evolution](/records/lexicon/controlled-evolution)", "term": "Depends on" }, { "description": "[Silent Breaking Changes](/records/lexicon/silent-breaking-changes)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-versioning", "title": "Versioning" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: integration, network, message", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that both ends of a connection speak a declared protocol version they both support.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Protocol Contract](/records/lexicon/protocol-contract), [Versioning](/records/architecture/versioning)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Multi-Client Integration](/records/lexicon/multi-client-integration)", "term": "Enables" }, { "description": "[Protocol Optimization](/records/lexicon/protocol-optimization)", "term": "In tension with" }, { "description": "[Proprietary Drift](/records/lexicon/proprietary-drift)", "term": "Conflicts with" }, { "description": "[Protocol Compatibility / Protocol Optimization](/records/tension/protocol-compatibility-protocol-optimization)", "term": "Tensions" }, { "description": "[Protocol Contract](/records/lexicon/protocol-contract): Protocol compatibility is both ends agreeing on a supported version, while the protocol contract is the set of messages and sequences that version defines.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Proprietary Drift](/records/lexicon/proprietary-drift)", "term": "Violated by" }, { "description": "protocol conformance failure", "term": "Detected by" }, { "description": "conformance test pass rate", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Standardize the Interface](/records/lexicon/standardize-the-interface)", "term": "Refactored by" }, { "description": "conformance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "socket.send(JSON.stringify({ action: \"save\", foo }));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooFrameV1 = { protocol: \"foo/1\"; type: \"save\"; payload: Foo };\nsocket.send(encodeFrame({ protocol: \"foo/1\", type: \"save\", payload: foo }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "conformance tests", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Protocol Contract](/records/lexicon/protocol-contract), [Versioning](/records/architecture/versioning), [Interoperability](/records/architecture/interoperability), [Multi-Client Integration](/records/lexicon/multi-client-integration)", "term": "Depends on" }, { "description": "[Proprietary Drift](/records/lexicon/proprietary-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-protocol-compatibility", "title": "Protocol Compatibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, data, protocol, system", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which separate systems exchange data and use it correctly through shared formats and contracts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Contracts](/records/lexicon/contracts), [Standards](/records/lexicon/standards), [Compatibility](/records/lexicon/compatibility)", "term": "Requires" }, { "description": "[Portability](/records/architecture/portability), [Integration](/records/lexicon/integration)", "term": "Reinforces" }, { "description": "[Cross-System Communication](/records/lexicon/cross-system-communication)", "term": "Enables" }, { "description": "[Domain-Specific Optimization](/records/lexicon/domain-specific-optimization)", "term": "In tension with" }, { "description": "[Proprietary Coupling](/records/lexicon/proprietary-coupling)", "term": "Conflicts with" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Contract-First Design](/records/architecture/contract-first-design), [API Contract](/records/architecture/api-contract), [Data Contract](/records/architecture/data-contract), [Protocol Compatibility](/records/architecture/protocol-compatibility), [Standards Compliance](/records/architecture/standards-compliance), [Integration Events](/records/architecture/integration-events), [Robustness Principle](/records/architecture/robustness-principle), [Standardization](/records/architecture/standardization), [Self-Describing API](/records/architecture/self-describing-api), [Adapter Pattern](/records/architecture/adapter-pattern), [Schema Validation](/records/architecture/schema-validation), [Canonical Data Model](/records/architecture/canonical-data-model), [Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Referenced by" }, { "description": "[Interoperability / Domain-Specific Optimization](/records/tension/domain-specific-optimization-interoperability)", "term": "Tensions" }, { "description": "[Portability](/records/architecture/portability): Interoperability is systems exchanging data correctly, while portability is software running on another platform unchanged.", "term": "Distinct from" }, { "description": "[Compatibility](/records/lexicon/compatibility): Interoperability is exchange through shared formats and contracts, while compatibility is working across versions without modification.", "term": "Distinct from" }, { "description": "[Data Quality](/records/lexicon/data-quality): Interoperability is exchange between systems, while data quality is the accuracy and completeness of the data exchanged.", "term": "Distinct from" }, { "description": "[Domain-Specific Optimization](/records/lexicon/domain-specific-optimization): Interoperability is broad exchange, while domain-specific optimization is the tuning for one domain it trades against.", "term": "Distinct from" }, { "description": "[Integration](/records/lexicon/integration): Interoperability is the ability to exchange data correctly, while integration is the degree systems are actually connected into one whole.", "term": "Distinct from" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency): Interoperability spans separate systems, while semantic consistency is one name keeping one meaning inside a system.", "term": "Distinct from" }, { "description": "[Discoverability](/records/lexicon/discoverability): Interoperability is exchanging data correctly, while discoverability is how easily a component's capabilities are found.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Proprietary Coupling](/records/lexicon/proprietary-coupling), [Implicit Assumptions](/records/lexicon/implicit-assumptions)", "term": "Violated by" }, { "description": "integration test failures", "term": "Detected by" }, { "description": "interoperability test coverage", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Extract Adapter](/records/lexicon/extract-adapter), [Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "contract tests, standards checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooClient.send(serializeWithPrivateFormat(foo));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const payload: JsonFooV1 = toJsonFooV1(foo);\nfooClient.send(JSON.stringify(payload), { contentType: \"application/json\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, standards checks", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Contracts](/records/lexicon/contracts), [Standards](/records/lexicon/standards), [Compatibility](/records/lexicon/compatibility), [Portability](/records/architecture/portability), [Integration](/records/lexicon/integration), [Cross-System Communication](/records/lexicon/cross-system-communication)", "term": "Depends on" }, { "description": "[Proprietary Coupling](/records/lexicon/proprietary-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-interoperability", "title": "Interoperability" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, resource boundary", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that every resource in an API uses the same verbs, response shapes and error format.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Consistent Semantics](/records/lexicon/consistent-semantics), [Stable Contracts](/records/lexicon/stable-contracts)", "term": "Requires" }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Reinforces" }, { "description": "[API Usability](/records/lexicon/api-usability)", "term": "Enables" }, { "description": "[Specialized Endpoints](/records/lexicon/specialized-endpoints)", "term": "In tension with" }, { "description": "[Ad-Hoc Endpoints](/records/lexicon/ad-hoc-endpoints), [Chatty Interface](/records/architecture/chatty-interface)", "term": "Conflicts with" }, { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" }, { "description": "[Uniform Interface / Specialized Endpoints](/records/tension/specialized-endpoints-uniform-interface)", "term": "Tensions" }, { "description": "[Consistent Semantics](/records/lexicon/consistent-semantics): A uniform interface fixes the same verbs, shapes and error format across resources, while consistent semantics fixes that an operation means the same thing everywhere.", "term": "Distinct from" }, { "description": "[Stable Contracts](/records/lexicon/stable-contracts): A uniform interface is sameness across resources, while stable contracts are sameness over time.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambiguous API](/records/lexicon/ambiguous-api), [Inconsistent Error Model](/records/architecture/inconsistent-error-model)", "term": "Violated by" }, { "description": "API lint violations", "term": "Detected by" }, { "description": "endpoint consistency score", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Standard Error Contract](/records/lexicon/standard-error-contract)", "term": "Refactored by" }, { "description": "API style guide, OpenAPI linting", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooApi.createFoo(foo);\nbarApi.post(\"/bar\", bar);\nbazApi.execute(\"DELETE_BAZ\", baz.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "resourceClient.post(\"/foos\", foo);\nresourceClient.post(\"/bars\", bar);\nresourceClient.delete(`/bazes/${baz.id}`);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API style guide, OpenAPI linting", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Consistent Semantics](/records/lexicon/consistent-semantics), [Stable Contracts](/records/lexicon/stable-contracts), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [API Usability](/records/lexicon/api-usability)", "term": "Depends on" }, { "description": "[Ad-Hoc Endpoints](/records/lexicon/ad-hoc-endpoints), [Chatty Interface](/records/architecture/chatty-interface)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-uniform-interface", "title": "Uniform Interface" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/architecture-category/contracts-interfaces-compatibility)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, service, integration", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a provider verifies each change against the expectations its consumers have recorded.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Requires" }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility), [Contract-First Design](/records/architecture/contract-first-design)", "term": "Reinforces" }, { "description": "[Provider Change Safety](/records/lexicon/provider-change-safety), [Consumer-Verified Compatibility](/records/lexicon/consumer-verified-compatibility)", "term": "Enables" }, { "description": "[Provider Autonomy](/records/lexicon/provider-autonomy)", "term": "In tension with" }, { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Conflicts with" }, { "description": "[Consumer-Driven Contracts / Provider Autonomy](/records/tension/consumer-driven-contracts-provider-autonomy)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Silent Breaking Changes](/records/lexicon/silent-breaking-changes)", "term": "Violated by" }, { "description": "integration breaks discovered only in production", "term": "Detected by" }, { "description": "consumer-break incident rate", "term": "Measured by" }, { "description": "[Consumer-Driven Contract Tests](/records/lexicon/consumer-driven-contract-tests)", "term": "Refactored by" }, { "description": "contract test gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooProvider.deploy(newFooApi);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const expectations = collectContractsFrom([\"bar-service\", \"baz-service\"]);\nconst result = verifyProvider(newFooApi, expectations);\nif (!result.satisfied) throw new BrokenConsumerContractError(result.violations);\nfooProvider.deploy(newFooApi);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract test gate", "term": "Checked by" }, { "description": "Every public boundary: operations, endpoints, messages, schemas and protocol frames", "term": "Population" }, { "description": "A verdict stands for one version of the contract and goes stale when the contract or its implementation changes", "term": "Freshness" }, { "description": "The contract test, schema validation or API diff gate fails the change that breaks the contract", "term": "Refusal" }, { "description": "The contract or schema compared with the implementation and with each consumer's recorded expectation", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the implementation and each consumer's recorded expectation are compared against", "term": "Authoritative side" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Backward Compatibility](/records/architecture/backward-compatibility), [Contract-First Design](/records/architecture/contract-first-design), [Provider Change Safety](/records/lexicon/provider-change-safety), [Consumer-Verified Compatibility](/records/lexicon/consumer-verified-compatibility)", "term": "Depends on" }, { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-consumer-driven-contracts", "title": "Consumer-Driven Contracts" } ], "title": "Contracts / Interfaces / Compatibility" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_control_plane[\"Control Plane\"]\n n_orchestration[\"Orchestration\"]\n n_centralized_configuration[\"Centralized Configuration\"]\n n_centralized_authentication[\"Centralized Authentication\"]\n n_centralized_logging[\"Centralized Logging\"]\n n_decentralization[\"Decentralization\"]\n n_leader_election[\"Leader Election\"]\n n_consensus[\"Consensus\"]\n n_choreography[\"Choreography\"]\n n_control_plane --> n_orchestration\n n_orchestration --> n_control_plane\n n_leader_election --> n_consensus\n n_leader_election --> n_control_plane\n n_choreography --> n_decentralization" } ], "icon": "bi-collection", "id": "architecture-category-control-coordination-centralization", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: platform, infrastructure, distributed system", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the desired state of a distributed runtime, held in one place and applied to every node through a management interface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Management API](/records/lexicon/management-api), [Policy](/records/lexicon/policy)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance), [Orchestration](/records/architecture/orchestration)", "term": "Reinforces" }, { "description": "[Centralized Control of Distributed Runtime](/records/lexicon/centralized-control-of-distributed-runtime)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability)", "term": "In tension with" }, { "description": "[Fully Decentralized Control](/records/lexicon/fully-decentralized-control)", "term": "Conflicts with" }, { "description": "[Orchestration](/records/architecture/orchestration), [Leader Election](/records/architecture/leader-election)", "term": "Referenced by" }, { "description": "[Control Plane](/records/algorithms/control-plane)", "term": "Contracts" }, { "description": "[Control Plane / Availability](/records/tension/availability-control-plane)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Configuration](/records/lexicon/scattered-configuration)", "term": "Violated by" }, { "description": "manual node/service control", "term": "Detected by" }, { "description": "control coverage, control-plane availability", "term": "Measured by" }, { "description": "[Management API](/records/lexicon/management-api), [Policy as Code](/records/architecture/policy-as-code)", "term": "Refactored by" }, { "description": "platform architecture", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "for (const node of fooNodes) {\n node.configure({ retries: 3, timeoutMs: 500 });\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "controlPlane.apply(\"foo-service\", {\n retries: 3,\n timeoutMs: 500,\n rollout: \"progressive\",\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "platform architecture", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Management API](/records/lexicon/management-api), [Policy](/records/lexicon/policy), [Governance](/records/architecture/governance), [Orchestration](/records/architecture/orchestration), [Centralized Control of Distributed Runtime](/records/lexicon/centralized-control-of-distributed-runtime)", "term": "Depends on" }, { "description": "[Fully Decentralized Control](/records/lexicon/fully-decentralized-control)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-control-plane", "title": "Control Plane" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: workflow, deployment, services", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that runs a multi-step workflow from one coordinator, which calls each step in order and tracks its outcome.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordinator](/records/lexicon/coordinator)", "term": "Requires" }, { "description": "[Control Plane](/records/architecture/control-plane), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Reinforces" }, { "description": "[Ordered Multi-Step Execution](/records/lexicon/ordered-multi-step-execution)", "term": "Enables" }, { "description": "[Centralized Coordinator Coupling](/records/lexicon/centralized-coordinator-coupling)", "term": "In tension with" }, { "description": "[Pure Choreography](/records/lexicon/pure-choreography)", "term": "Conflicts with" }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Referenced by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Contracts" }, { "description": "[Orchestration / Centralized Coordinator Coupling](/records/tension/centralized-coordinator-coupling-orchestration)", "term": "Tensions" }, { "description": "[Coordinator](/records/lexicon/coordinator): Orchestration is the mechanism of driving a workflow from one place, while the coordinator is the component that plays that role.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Pure Choreography](/records/lexicon/pure-choreography)", "term": "Violated by" }, { "description": "unclear workflow ownership", "term": "Detected by" }, { "description": "workflow observability/completion", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "workflow tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooService.create(foo);\nawait barService.create(bar);\nawait bazService.create(baz);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await orchestrator.run(\"CreateFooFlow\", {\n steps: [\n step(\"foo\", () => fooService.create(foo)),\n step(\"bar\", () => barService.create(bar)),\n step(\"baz\", () => bazService.create(baz)),\n ],\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "workflow tests", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Coordinator](/records/lexicon/coordinator), [Control Plane](/records/architecture/control-plane), [Saga Pattern](/records/architecture/saga-pattern), [Ordered Multi-Step Execution](/records/lexicon/ordered-multi-step-execution)", "term": "Depends on" }, { "description": "[Pure Choreography](/records/lexicon/pure-choreography)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-orchestration", "title": "Orchestration" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, platform, runtime", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that keeps every service's configuration in one versioned store the services read from.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Config Store](/records/lexicon/config-store), [Access Control](/records/architecture/access-control)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Unified Config Management](/records/lexicon/unified-config-management)", "term": "Enables" }, { "description": "[Central Dependency Risk](/records/lexicon/central-dependency-risk)", "term": "In tension with" }, { "description": "[Scattered Configuration](/records/lexicon/scattered-configuration)", "term": "Conflicts with" }, { "description": "[Centralized Configuration / Central Dependency Risk](/records/tension/central-dependency-risk-centralized-configuration)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Configuration](/records/lexicon/scattered-configuration)", "term": "Violated by" }, { "description": "config drift", "term": "Detected by" }, { "description": "config drift count", "term": "Measured by" }, { "description": "[Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "config policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooConfig = loadLocalFooConfig();\nconst barConfig = loadLocalBarConfig();\nconst bazConfig = loadLocalBazConfig();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const config = await configService.readVersioned(\"platform/v3\");\nfooApp.apply(config.foo);\nbarApp.apply(config.bar);\nbazApp.apply(config.baz);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "config policy", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Config Store](/records/lexicon/config-store), [Access Control](/records/architecture/access-control), [Governance](/records/architecture/governance), [Consistency](/records/architecture/consistency), [Unified Config Management](/records/lexicon/unified-config-management)", "term": "Depends on" }, { "description": "[Scattered Configuration](/records/lexicon/scattered-configuration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-centralized-configuration", "title": "Centralized Configuration" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: identity, system", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that verifies identity once, at a shared identity provider, and passes the result to each service.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Identity Provider](/records/lexicon/identity-provider)", "term": "Requires" }, { "description": "[Security](/records/lexicon/security), [Governance](/records/architecture/governance)", "term": "Reinforces" }, { "description": "[Unified Identity](/records/lexicon/unified-identity)", "term": "Enables" }, { "description": "[Identity Provider Availability](/records/lexicon/identity-provider-availability)", "term": "In tension with" }, { "description": "[Scattered Auth Implementations](/records/lexicon/scattered-auth-implementations)", "term": "Conflicts with" }, { "description": "[Centralized Authentication / Identity Provider Availability](/records/tension/centralized-authentication-identity-provider-availability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Auth Implementations](/records/lexicon/scattered-auth-implementations)", "term": "Violated by" }, { "description": "duplicated credential stores", "term": "Detected by" }, { "description": "auth centralization coverage", "term": "Measured by" }, { "description": "[Identity Provider](/records/lexicon/identity-provider)", "term": "Refactored by" }, { "description": "[security policy](/records/algorithms/security-policy)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooService.verifyToken(token);\nbarService.verifyToken(token);\nbazService.verifyToken(token);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const identity = await identityProvider.authenticate(token);\nawait fooService.handle({ identity });\nawait barService.handle({ identity });\nawait bazService.handle({ identity });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security policy", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Identity Provider](/records/lexicon/identity-provider), [Security](/records/lexicon/security), [Governance](/records/architecture/governance), [Unified Identity](/records/lexicon/unified-identity)", "term": "Depends on" }, { "description": "[Scattered Auth Implementations](/records/lexicon/scattered-auth-implementations)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-centralized-authentication", "title": "Centralized Authentication" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: services, platform", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that ships structured logs from every instance to one aggregated store.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Log Aggregation](/records/lexicon/log-aggregation)", "term": "Requires" }, { "description": "[Observability](/records/architecture/observability), [Auditability](/records/architecture/auditability)", "term": "Reinforces" }, { "description": "[Cross-Service Analysis](/records/lexicon/cross-service-analysis)", "term": "Enables" }, { "description": "[Cost/Personal Data Exposure](/records/lexicon/cost-personal-data-exposure)", "term": "In tension with" }, { "description": "[Local-Only Logs](/records/lexicon/local-only-logs)", "term": "Conflicts with" }, { "description": "[Centralized Logging / Cost/Personal Data Exposure](/records/tension/centralized-logging-cost-personal-data-exposure)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Local-Only Logs](/records/lexicon/local-only-logs)", "term": "Violated by" }, { "description": "missing log shipping", "term": "Detected by" }, { "description": "log ingestion coverage", "term": "Measured by" }, { "description": "[Log Aggregation](/records/lexicon/log-aggregation), [Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Refactored by" }, { "description": "observability policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooService.writeLocalLog(event);\nbarService.writeLocalLog(event);\nbazService.writeLocalLog(event);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const sink = new CentralLogSink();\nfooService.useLogger(structuredLogger(sink));\nbarService.useLogger(structuredLogger(sink));\nbazService.useLogger(structuredLogger(sink));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "observability policy", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Log Aggregation](/records/lexicon/log-aggregation), [Observability](/records/architecture/observability), [Auditability](/records/architecture/auditability), [Cross-Service Analysis](/records/lexicon/cross-service-analysis)", "term": "Depends on" }, { "description": "[Local-Only Logs](/records/lexicon/local-only-logs)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-centralized-logging", "title": "Centralized Logging" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, team, service", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that decisions and runtime control sit with the teams and services that own them, joined by contracts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Autonomy](/records/architecture/autonomy), [Contracts](/records/lexicon/contracts)", "term": "Requires" }, { "description": "[Microservices](/records/architecture/microservices), [Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Independent Ownership](/records/lexicon/independent-ownership)", "term": "Enables" }, { "description": "[Governance](/records/architecture/governance), [Consistency](/records/architecture/consistency)", "term": "In tension with" }, { "description": "[Centralized Control](/records/lexicon/centralized-control)", "term": "Conflicts with" }, { "description": "[Choreography](/records/architecture/choreography), [Autonomy](/records/architecture/autonomy), [Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Referenced by" }, { "description": "[Decentralization / Governance](/records/tension/decentralization-governance), [Decentralization / Consistency](/records/tension/consistency-decentralization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Centralized Control](/records/lexicon/centralized-control)", "term": "Violated by" }, { "description": "centralized team/service dependency", "term": "Detected by" }, { "description": "decision/deployment dependency count", "term": "Measured by" }, { "description": "[Assign Owner](/records/lexicon/assign-owner), [Management API](/records/lexicon/management-api)", "term": "Refactored by" }, { "description": "ownership model", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const coordinator = new GlobalFooCoordinator();\nawait coordinator.approveEveryFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await fooNode.validate(foo);\nawait fooNode.commit(foo);\nawait fooNode.publish({ type: \"FooCommitted\", fooId: foo.id });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "ownership model", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Autonomy](/records/architecture/autonomy), [Contracts](/records/lexicon/contracts), [Microservices](/records/architecture/microservices), [Resilience](/records/architecture/resilience), [Independent Ownership](/records/lexicon/independent-ownership)", "term": "Depends on" }, { "description": "[Centralized Control](/records/lexicon/centralized-control)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-decentralization", "title": "Decentralization" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: distributed system, coordination, availability", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a group of nodes agree on one coordinator and replace it when it fails.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Consensus](/records/architecture/consensus)", "term": "Requires" }, { "description": "[Control Plane](/records/architecture/control-plane), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Single-Writer Coordination](/records/lexicon/single-writer-coordination), [Automatic Failover of Leadership](/records/lexicon/automatic-failover-of-leadership)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability)", "term": "In tension with" }, { "description": "[Split-Brain Coordination](/records/lexicon/split-brain-coordination)", "term": "Conflicts with" }, { "description": "[Leader Election / Availability](/records/tension/availability-leader-election)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Split-Brain Coordination](/records/lexicon/split-brain-coordination)", "term": "Violated by" }, { "description": "concurrent leader actions / split-brain", "term": "Detected by" }, { "description": "split-brain incident rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (process.env.IS_LEADER === \"true\") runFooScheduler();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const lease = await fooCoordinator.acquireLeadership(\"foo-scheduler\", { ttlMs: 10_000 });\nlease.onAcquired(() => runFooScheduler());\nlease.onLost(() => stopFooScheduler());", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Consensus](/records/architecture/consensus), [Control Plane](/records/architecture/control-plane), [Fault Tolerance](/records/architecture/fault-tolerance), [Single-Writer Coordination](/records/lexicon/single-writer-coordination), [Automatic Failover of Leadership](/records/lexicon/automatic-failover-of-leadership)", "term": "Depends on" }, { "description": "[Split-Brain Coordination](/records/lexicon/split-brain-coordination)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-leader-election", "title": "Leader Election" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: distributed system, agreement, consistency", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a quorum of nodes commit one value, so every correct node ends up with the same value.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Quorum](/records/lexicon/quorum)", "term": "Requires" }, { "description": "[Consistency](/records/architecture/consistency), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Agreed Single Value Across Nodes](/records/lexicon/agreed-single-value-across-nodes)", "term": "Enables" }, { "description": "[Latency](/records/architecture/latency), [Availability](/records/lexicon/availability)", "term": "In tension with" }, { "description": "[Independent Node Decisions](/records/lexicon/independent-node-decisions)", "term": "Conflicts with" }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast), [Leader Election](/records/architecture/leader-election)", "term": "Referenced by" }, { "description": "[Consensus / Latency](/records/tension/consensus-latency), [Consensus / Availability](/records/tension/availability-consensus)", "term": "Tensions" }, { "description": "[Leader Election](/records/architecture/leader-election): Consensus commits one value across a quorum, while leader election uses it to agree on one coordinator and replace it when it fails.", "term": "Distinct from" }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast): Consensus agrees on one value, while total-order broadcast agrees on the order of every message.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Independent Node Decisions](/records/lexicon/independent-node-decisions)", "term": "Violated by" }, { "description": "divergent committed state across replicas", "term": "Detected by" }, { "description": "agreement-violation rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "distributed-systems review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooNodeA.setValue(value);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const committed = await fooCluster.propose(value, { quorum: majority(fooNodes) });\nif (!committed.accepted) throw new NoQuorumError();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "distributed-systems review", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Quorum](/records/lexicon/quorum), [Consistency](/records/architecture/consistency), [Fault Tolerance](/records/architecture/fault-tolerance), [Agreed Single Value Across Nodes](/records/lexicon/agreed-single-value-across-nodes)", "term": "Depends on" }, { "description": "[Independent Node Decisions](/records/lexicon/independent-node-decisions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-consensus", "title": "Consensus" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/architecture-category/control-coordination-centralization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed system, coordination, event", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that coordinates a cross-service flow through events, with each service reacting to the previous one's event.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Requires" }, { "description": "[Decentralization](/records/architecture/decentralization), [Autonomy](/records/architecture/autonomy)", "term": "Reinforces" }, { "description": "[Central-Orchestrator-Free Coordination](/records/lexicon/central-orchestrator-free-coordination)", "term": "Enables" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "In tension with" }, { "description": "[Central Orchestrator Bottleneck](/records/lexicon/central-orchestrator-bottleneck)", "term": "Conflicts with" }, { "description": "[Choreography / Traceability](/records/tension/choreography-traceability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Central Orchestrator Bottleneck](/records/lexicon/central-orchestrator-bottleneck)", "term": "Violated by" }, { "description": "a central coordinator coupled to all participants", "term": "Detected by" }, { "description": "orchestrator fan-out coupling", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await orchestrator.run(\"CreateFoo\", [\n () => createFoo(foo),\n () => reserveBar(foo),\n () => notifyBaz(foo),\n]);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooEvents.on(\"FooCreated\", event => barService.reserve(event.fooId));\nbarEvents.on(\"BarReserved\", event => bazService.notify(event.fooId));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every node, service and workflow step that shares configuration, identity, logs, leadership or agreement", "term": "Population" }, { "description": "A verdict stands until membership, topology or the coordinating policy changes", "term": "Freshness" }, { "description": "The workflow test or the platform policy rejects a participant that bypasses the coordinator or the agreed value", "term": "Refusal" }, { "description": "The control plane's recorded state compared with each participant's reported state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The control plane's recorded state, which each participant's reported state is compared against", "term": "Authoritative side" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Decentralization](/records/architecture/decentralization), [Autonomy](/records/architecture/autonomy), [Central-Orchestrator-Free Coordination](/records/lexicon/central-orchestrator-free-coordination)", "term": "Depends on" }, { "description": "[Central Orchestrator Bottleneck](/records/lexicon/central-orchestrator-bottleneck)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-choreography", "title": "Choreography" } ], "title": "Control / Coordination / Centralization" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_determinism[\"Determinism\"]\n n_predictability[\"Predictability\"]\n n_referential_transparency[\"Referential Transparency\"]\n n_pure_functions[\"Pure Functions\"]\n n_immutability[\"Immutability\"]\n n_reproducibility[\"Reproducibility\"]\n n_repeatability[\"Repeatability\"]\n n_correctness[\"Correctness\"]\n n_formal_verification[\"Formal Verification\"]\n n_specification_based_testing[\"Specification-Based Testing\"]\n n_property_based_testing[\"Property-Based Testing\"]\n n_static_analysis[\"Static Analysis\"]\n n_testability[\"Testability\"]\n n_validation[\"Validation\"]\n n_verification[\"Verification\"]\n n_determinism --> n_predictability\n n_determinism --> n_reproducibility\n n_predictability --> n_determinism\n n_referential_transparency --> n_pure_functions\n n_referential_transparency --> n_immutability\n n_referential_transparency --> n_determinism\n n_referential_transparency --> n_testability\n n_pure_functions --> n_testability\n n_pure_functions --> n_determinism\n n_pure_functions --> n_referential_transparency\n n_immutability --> n_predictability\n n_reproducibility --> n_determinism\n n_repeatability --> n_verification\n n_repeatability --> n_predictability\n n_correctness --> n_validation\n n_formal_verification --> n_correctness\n n_specification_based_testing --> n_correctness\n n_property_based_testing --> n_correctness\n n_testability --> n_pure_functions\n n_validation --> n_correctness\n n_verification --> n_correctness" } ], "icon": "bi-collection", "id": "architecture-category-correctness-determinism-verification", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, process, build, test", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that the same inputs and state always produce the same result, with time and randomness passed in as inputs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Controlled State](/records/lexicon/controlled-state), [Controlled State](/records/lexicon/controlled-state)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Reproducibility](/records/architecture/reproducibility)", "term": "Reinforces" }, { "description": "[Reliable Testing](/records/lexicon/reliable-testing)", "term": "Enables" }, { "description": "[Runtime Adaptivity](/records/lexicon/runtime-adaptivity)", "term": "In tension with" }, { "description": "[Hidden Time/Randomness/Global State](/records/lexicon/hidden-time-randomness-global-state)", "term": "Conflicts with" }, { "description": "[Predictability](/records/architecture/predictability), [Referential Transparency](/records/architecture/referential-transparency), [Pure Functions](/records/architecture/pure-functions), [Reproducibility](/records/architecture/reproducibility), [Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Agentic Architecture](/records/architecture/agentic-architecture), [Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [One-Sided Liveness](/records/architecture/one-sided-liveness), [Declare-Before-Read Order](/records/architecture/declare-before-read-order), [Derived Party Count](/records/architecture/derived-party-count), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" }, { "description": "[Computation Core](/records/algorithms/computation-core)", "term": "Contracts" }, { "description": "[Determinism / Runtime Adaptivity](/records/tension/determinism-runtime-adaptivity)", "term": "Tensions" }, { "description": "[Referential Transparency](/records/architecture/referential-transparency): Determinism is the same inputs giving the same result, while referential transparency is being able to replace an expression by its value.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Time/Randomness/Global State](/records/lexicon/hidden-time-randomness-global-state)", "term": "Violated by" }, { "description": "flaky tests, hidden random/time calls", "term": "Detected by" }, { "description": "flake rate, reproducibility score", "term": "Measured by" }, { "description": "[Inject Clock and Randomness](/records/lexicon/inject-clock-and-randomness), [Encapsulate State](/records/lexicon/encapsulate-state)", "term": "Refactored by" }, { "description": "deterministic test rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function makeFoo(name: string) {\n return { id: crypto.randomUUID(), name, createdAt: new Date() };\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function makeFoo(name: string, id: FooId, createdAt: Date): Foo {\n return { id, name, createdAt };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deterministic test rules", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Controlled State](/records/lexicon/controlled-state), [Controlled State](/records/lexicon/controlled-state), [Predictability](/records/architecture/predictability), [Reproducibility](/records/architecture/reproducibility), [Reliable Testing](/records/lexicon/reliable-testing)", "term": "Depends on" }, { "description": "[Hidden Time/Randomness/Global State](/records/lexicon/hidden-time-randomness-global-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-determinism", "title": "Determinism" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, module, runtime", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a caller can foresee what an operation does from its interface and contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Determinism](/records/architecture/determinism), [Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Requires" }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Reinforces" }, { "description": "[Safe Refactoring](/records/lexicon/safe-refactoring)", "term": "Enables" }, { "description": "[Dynamic Runtime Behavior](/records/lexicon/dynamic-runtime-behavior)", "term": "In tension with" }, { "description": "[Hidden Behavior](/records/lexicon/hidden-behavior)", "term": "Conflicts with" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Dynamic Binding](/records/architecture/dynamic-binding), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Design by Contract](/records/architecture/design-by-contract), [Explicit Contracts](/records/architecture/explicit-contracts), [API Contract](/records/architecture/api-contract), [Postconditions](/records/architecture/postconditions), [Determinism](/records/architecture/determinism), [Immutability](/records/architecture/immutability), [Repeatability](/records/architecture/repeatability), [Pattern Consistency](/records/architecture/pattern-consistency), [Declarative Configuration](/records/architecture/declarative-configuration), [Convention over Configuration](/records/architecture/convention-over-configuration), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [State Isolation](/records/architecture/state-isolation), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" }, { "description": "[Predictability / Dynamic Runtime Behavior](/records/tension/dynamic-runtime-behavior-predictability)", "term": "Tensions" }, { "description": "[Correctness](/records/architecture/correctness): Predictability is foreseeing behavior from the contract, while correctness is the behavior matching its specification.", "term": "Distinct from" }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency): Predictability is foreseeing one operation, while pattern consistency is one problem solved one way across the codebase.", "term": "Distinct from" }, { "description": "[Interoperability](/records/architecture/interoperability): Predictability is a caller foreseeing behavior, while interoperability is systems exchanging data.", "term": "Distinct from" }, { "description": "[Reproducibility](/records/architecture/reproducibility): Predictability is foreseeing what an operation does, while reproducibility is a run giving the same output from pinned inputs on another machine.", "term": "Distinct from" }, { "description": "[Testability](/records/architecture/testability): Predictability is foreseeing behavior, while testability is exercising code in isolation.", "term": "Distinct from" }, { "description": "[Concurrency Correctness](/records/lexicon/concurrency-correctness): Predictability is foreseeing behavior from a contract, while concurrency correctness is freedom from races when units run at once.", "term": "Distinct from" }, { "description": "[Dynamic Runtime Behavior](/records/lexicon/dynamic-runtime-behavior): Predictability is foreseeable behavior, while dynamic runtime behavior is the adaptivity that undermines it.", "term": "Distinct from" }, { "description": "[Maintainability](/records/lexicon/maintainability): Predictability is foreseeing behavior, while maintainability is the ease of changing it.", "term": "Distinct from" }, { "description": "[Security](/records/lexicon/security): Predictability is foreseeable behavior, while security is protection from misuse.", "term": "Distinct from" }, { "description": "[Startup Cost](/records/lexicon/startup-cost): Predictability is foreseeable behavior, while startup cost is the time discovery adds at initialization.", "term": "Distinct from" }, { "description": "[Repeatability](/records/architecture/repeatability): Predictability is foreseeing an outcome from the contract, while repeatability is rerunning and observing the same outcome.", "term": "Distinct from" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility): Predictability is fixed, foreseeable behavior, while runtime extensibility is adding capability to a running system.", "term": "Distinct from" }, { "description": "[Static Safety](/records/lexicon/static-safety): Predictability is a caller foreseeing behavior, while static safety is the compiler catching classes of error before the code runs.", "term": "Distinct from" }, { "description": "[Thread Safety](/records/lexicon/thread-safety): Predictability is foreseeing behavior from a contract, while thread safety is data surviving concurrent access uncorrupted.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect), [Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Violated by" }, { "description": "nondeterministic tests, ambiguous APIs", "term": "Detected by" }, { "description": "flake/misuse rate", "term": "Measured by" }, { "description": "[Declare Capability](/records/lexicon/declare-capability), [Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "[tests](/records/lexicon/tests), [contracts](/records/lexicon/contracts), linting", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) {\n if (Math.random() > 0.5) return memoryStore.save(foo);\n return sqlStore.save(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function saveFoo(store: FooStore, foo: Foo) { return store.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "tests, contracts, linting", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Determinism](/records/architecture/determinism), [Explicit Contracts](/records/architecture/explicit-contracts), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [Safe Refactoring](/records/lexicon/safe-refactoring)", "term": "Depends on" }, { "description": "[Hidden Behavior](/records/lexicon/hidden-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-predictability", "title": "Predictability" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: function, expression", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an expression can be replaced by its value without changing the program's behavior.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Pure Functions](/records/architecture/pure-functions), [Immutability](/records/architecture/immutability)", "term": "Requires" }, { "description": "[Determinism](/records/architecture/determinism), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Safe Substitution](/records/lexicon/safe-substitution)", "term": "Enables" }, { "description": "[Stateful IO](/records/lexicon/stateful-io)", "term": "In tension with" }, { "description": "[Side Effects](/records/lexicon/side-effects)", "term": "Conflicts with" }, { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Referenced by" }, { "description": "[Referential Transparency / Stateful IO](/records/tension/referential-transparency-stateful-io)", "term": "Tensions" }, { "description": "[Immutability](/records/architecture/immutability): Referential transparency lets an expression be replaced by its value, while immutability forbids a value from changing after creation.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Time/Randomness/Global State](/records/lexicon/hidden-time-randomness-global-state)", "term": "Violated by" }, { "description": "hidden dependency on time/random/global state", "term": "Detected by" }, { "description": "pure function coverage", "term": "Measured by" }, { "description": "[Pure Functions](/records/architecture/pure-functions), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "[code review](/records/architecture/code-review), functional boundaries", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function fooTotal(values: number[]) {\n globalCounter += 1;\n return values.reduce((a, b) => a + b, 0) + globalCounter;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function fooTotal(values: readonly number[]) {\n return values.reduce((a, b) => a + b, 0);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "code review, functional boundaries", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Pure Functions](/records/architecture/pure-functions), [Immutability](/records/architecture/immutability), [Determinism](/records/architecture/determinism), [Testability](/records/architecture/testability), [Safe Substitution](/records/lexicon/safe-substitution)", "term": "Depends on" }, { "description": "[Side Effects](/records/lexicon/side-effects)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-referential-transparency", "title": "Referential Transparency" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, domain logic", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing logic as functions whose result depends only on their arguments and which have no side effects.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[No Side Effects](/records/lexicon/no-side-effects), [Explicit Inputs](/records/lexicon/explicit-inputs)", "term": "Requires" }, { "description": "[Testability](/records/architecture/testability), [Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Referential Transparency](/records/architecture/referential-transparency)", "term": "Enables" }, { "description": "[Stateful Operations](/records/lexicon/stateful-operations)", "term": "In tension with" }, { "description": "[Hidden IO](/records/lexicon/hidden-io)", "term": "Conflicts with" }, { "description": "[Referential Transparency](/records/architecture/referential-transparency), [Testability](/records/architecture/testability)", "term": "Referenced by" }, { "description": "[Pure Functions / Stateful Operations](/records/tension/pure-functions-stateful-operations)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Side Effects](/records/lexicon/side-effects), [Hidden IO](/records/lexicon/hidden-io)", "term": "Violated by" }, { "description": "side-effect calls inside pure layer", "term": "Detected by" }, { "description": "pure core ratio", "term": "Measured by" }, { "description": "[Pure Core / Imperative Shell](/records/lexicon/pure-core-imperative-shell)", "term": "Refactored by" }, { "description": "layer rules, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function normalizeFoo(foo: Foo) {\n foo.name = foo.name.trim();\n fooStore.save(foo);\n return foo;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function normalizeFoo(foo: Foo): Foo {\n return { ...foo, name: foo.name.trim() };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "layer rules, tests", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[No Side Effects](/records/lexicon/no-side-effects), [Explicit Inputs](/records/lexicon/explicit-inputs), [Testability](/records/architecture/testability), [Determinism](/records/architecture/determinism), [Referential Transparency](/records/architecture/referential-transparency)", "term": "Depends on" }, { "description": "[Hidden IO](/records/lexicon/hidden-io)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pure-functions", "title": "Pure Functions" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: data, value object, concurrency", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a value is never changed after it is created, and a change produces a new value.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Value Semantics](/records/lexicon/value-semantics)", "term": "Requires" }, { "description": "[Thread Safety](/records/lexicon/thread-safety), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Safe Sharing](/records/lexicon/safe-sharing)", "term": "Enables" }, { "description": "[Allocation Cost](/records/lexicon/allocation-cost)", "term": "In tension with" }, { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Conflicts with" }, { "description": "[Value Object](/records/architecture/value-object), [Referential Transparency](/records/architecture/referential-transparency), [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Referenced by" }, { "description": "[Immutability / Allocation Cost](/records/tension/allocation-cost-immutability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state), [Exposed Internals](/records/lexicon/exposed-internals)", "term": "Violated by" }, { "description": "setters on value objects, mutable public fields", "term": "Detected by" }, { "description": "mutable state count", "term": "Measured by" }, { "description": "[Make Immutable](/records/lexicon/make-immutable)", "term": "Refactored by" }, { "description": "type system, lint rules", "term": "Enforced by" }, { "description": "immutability", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "type Foo = { name: string; tags: string[] };\nfunction addTag(foo: Foo, tag: string) { foo.tags.push(tag); return foo; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type Foo = Readonly<{ name: string; tags: readonly string[] }>;\nfunction addTag(foo: Foo, tag: string): Foo { return { ...foo, tags: [...foo.tags, tag] }; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "type system, lint rules", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Value Semantics](/records/lexicon/value-semantics), [Thread Safety](/records/lexicon/thread-safety), [Predictability](/records/architecture/predictability), [Safe Sharing](/records/lexicon/safe-sharing)", "term": "Depends on" }, { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-immutability", "title": "Immutability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: build, test, deployment, ML", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a build, test or training run gives the same output from the same pinned inputs on another machine.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Determinism](/records/architecture/determinism), [Versioned Inputs](/records/lexicon/versioned-inputs)", "term": "Requires" }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Reinforces" }, { "description": "[Debugging](/records/lexicon/debugging), [Compliance](/records/architecture/compliance)", "term": "Enables" }, { "description": "[Continuous Updates](/records/lexicon/continuous-updates)", "term": "In tension with" }, { "description": "[Floating Dependencies](/records/lexicon/floating-dependencies), [Flaky Test Normalization](/records/architecture/flaky-test-normalization)", "term": "Conflicts with" }, { "description": "[Determinism](/records/architecture/determinism), [Environment Parity](/records/architecture/environment-parity), [Infrastructure as Code](/records/architecture/infrastructure-as-code), [Immutable Infrastructure](/records/architecture/immutable-infrastructure), [Machine Learning Architecture](/records/architecture/machine-learning-architecture), [Prompt Engineering](/records/architecture/prompt-engineering), [Benchmarking](/records/architecture/benchmarking)", "term": "Referenced by" }, { "description": "[Reproducibility / Continuous Updates](/records/tension/continuous-updates-reproducibility)", "term": "Tensions" }, { "description": "[Continuous Updates](/records/lexicon/continuous-updates): Reproducibility pins every input, while continuous updates are the dependency changes that pinning holds back.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Floating Dependencies](/records/lexicon/floating-dependencies)", "term": "Violated by" }, { "description": "build output drift", "term": "Detected by" }, { "description": "reproducible build/test pass rate", "term": "Measured by" }, { "description": "[Pin Versions](/records/lexicon/pin-versions)", "term": "Refactored by" }, { "description": "lockfiles, build verification", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const result = trainFoo(data, { seed: Math.random() });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const config = { seed: 42, datasetVersion: \"foo-v3\", algorithmVersion: \"1.2.0\" } as const;\nconst result = trainFoo(data, config);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lockfiles, build verification", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Determinism](/records/architecture/determinism), [Versioned Inputs](/records/lexicon/versioned-inputs), [Auditability](/records/architecture/auditability), [Debugging](/records/lexicon/debugging), [Compliance](/records/architecture/compliance)", "term": "Depends on" }, { "description": "[Floating Dependencies](/records/lexicon/floating-dependencies), [Flaky Test Normalization](/records/architecture/flaky-test-normalization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-reproducibility", "title": "Reproducibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: test, build, process", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which rerunning the same test or process in the same environment gives the same result.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Controlled State](/records/lexicon/controlled-state)", "term": "Requires" }, { "description": "[Verification](/records/architecture/verification), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Reliable Automation](/records/lexicon/reliable-automation)", "term": "Enables" }, { "description": "[Real-World Variability](/records/lexicon/real-world-variability)", "term": "In tension with" }, { "description": "[Environment-Sensitive Behavior](/records/lexicon/environment-sensitive-behavior)", "term": "Conflicts with" }, { "description": "[Repeatability / Real-World Variability](/records/tension/real-world-variability-repeatability)", "term": "Tensions" }, { "description": "[Real-World Variability](/records/lexicon/real-world-variability): Repeatability is the same result from a controlled rerun, while real-world variability is how far those controlled conditions differ from production.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Environment-Sensitive Behavior](/records/lexicon/environment-sensitive-behavior)", "term": "Violated by" }, { "description": "flaky test results", "term": "Detected by" }, { "description": "rerun consistency", "term": "Measured by" }, { "description": "[Containerization](/records/architecture/containerization), [Fake at the Boundary](/records/lexicon/fake-at-the-boundary)", "term": "Refactored by" }, { "description": "CI rerun policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "test(\"foo\", () => expect(runFoo(Date.now())).toEqual(snapshot()));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "test(\"foo\", () => {\n const clock = new FixedClock(\"2026-01-01T00:00:00Z\");\n expect(runFoo(clock)).toEqual(expectedFoo);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI rerun policy", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Controlled State](/records/lexicon/controlled-state), [Verification](/records/architecture/verification), [Predictability](/records/architecture/predictability), [Reliable Automation](/records/lexicon/reliable-automation)", "term": "Depends on" }, { "description": "[Environment-Sensitive Behavior](/records/lexicon/environment-sensitive-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-repeatability", "title": "Repeatability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, module, system", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the behavior of code matches its specification.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Specification](/records/lexicon/specification), [Validation](/records/architecture/validation), [Tests](/records/lexicon/tests)", "term": "Requires" }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Reinforces" }, { "description": "[Safe Operation](/records/lexicon/safe-operation)", "term": "Enables" }, { "description": "[Delivery Speed](/records/lexicon/delivery-speed)", "term": "In tension with" }, { "description": "[Undefined Behavior](/records/lexicon/undefined-behavior)", "term": "Conflicts with" }, { "description": "[Domain Model](/records/architecture/domain-model), [Happens-Before Relationship](/records/architecture/happens-before-relationship), [Design by Contract](/records/architecture/design-by-contract), [Semantic Contracts](/records/architecture/semantic-contracts), [Preconditions](/records/architecture/preconditions), [Postconditions](/records/architecture/postconditions), [Invariant](/records/architecture/invariant), [Formal Verification](/records/architecture/formal-verification), [Specification-Based Testing](/records/architecture/specification-based-testing), [Property-Based Testing](/records/architecture/property-based-testing), [Validation](/records/architecture/validation), [Verification](/records/architecture/verification), [Fail Fast](/records/architecture/fail-fast), [Error Handling](/records/architecture/error-handling), [Design Review](/records/architecture/design-review), [First-Principles Design](/records/architecture/first-principles-design), [Model Evaluation](/records/architecture/model-evaluation), [Finite State Machine](/records/architecture/finite-state-machine), [Schema Validation](/records/architecture/schema-validation), [Type Safety](/records/architecture/type-safety), [Single Source of Truth](/records/architecture/single-source-of-truth), [Semantic Consistency](/records/architecture/semantic-consistency), [Input Validation](/records/architecture/input-validation), [Atomicity](/records/architecture/atomicity), [ACID](/records/architecture/acid), [Consistency](/records/architecture/consistency), [Isolation](/records/architecture/isolation), [Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" }, { "description": "[Correctness / Delivery Speed](/records/tension/correctness-delivery-speed)", "term": "Tensions" }, { "description": "[Interoperability](/records/architecture/interoperability): Correctness is code matching its specification, while interoperability is separate systems exchanging data correctly.", "term": "Distinct from" }, { "description": "[Observability](/records/architecture/observability): Correctness is matching the specification, while observability is inferring behavior from the signals a system emits.", "term": "Distinct from" }, { "description": "[Maintainability](/records/lexicon/maintainability): Correctness is behaving as specified now, while maintainability is the ease of changing the behavior later.", "term": "Distinct from" }, { "description": "[Robustness](/records/lexicon/robustness): Correctness is behaving as specified for valid input, while robustness is continuing to operate under invalid input and stress.", "term": "Distinct from" }, { "description": "[Simplicity](/records/lexicon/simplicity): Correctness is matching the specification, while simplicity is the absence of unneeded structure.", "term": "Distinct from" }, { "description": "[Model Safety](/records/architecture/model-safety): Correctness is matching a specification, while model safety is preventing harmful model inputs, outputs and actions.", "term": "Distinct from" }, { "description": "[Resilience](/records/architecture/resilience): Correctness is right behavior, while resilience is containing failure and recovering from it.", "term": "Distinct from" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency): Correctness is behavior matching the specification, while semantic consistency is one name keeping one meaning.", "term": "Distinct from" }, { "description": "[Security](/records/lexicon/security): Correctness is matching the specification, while security is protecting data and behavior from misuse.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Undefined Behavior](/records/lexicon/undefined-behavior)", "term": "Violated by" }, { "description": "failing tests, invariant violations", "term": "Detected by" }, { "description": "defect rate, spec coverage", "term": "Measured by" }, { "description": "[Unit Tests](/records/lexicon/unit-tests), [Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "CI, formal/static checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function averageFoo(total: number, count: number) { return total / count; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function averageFoo(total: number, count: number) {\n if (!Number.isFinite(total)) throw new Error(\"invalid total\");\n if (!Number.isInteger(count) || count <= 0) throw new Error(\"invalid count\");\n return total / count;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI, formal/static checks", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Specification](/records/lexicon/specification), [Validation](/records/architecture/validation), [Tests](/records/lexicon/tests), [Design by Contract](/records/architecture/design-by-contract), [Safe Operation](/records/lexicon/safe-operation)", "term": "Depends on" }, { "description": "[Undefined Behavior](/records/lexicon/undefined-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-correctness", "title": "Correctness" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, protocol, critical system", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of proving, against a formal specification, that an algorithm or protocol keeps its invariants for every input.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Formal Specification](/records/lexicon/formal-specification)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Mathematical Assurance](/records/lexicon/mathematical-assurance)", "term": "Enables" }, { "description": "[Cost/Complexity](/records/lexicon/cost-complexity)", "term": "In tension with" }, { "description": "[Informal Validation Only](/records/lexicon/informal-validation-only)", "term": "Conflicts with" }, { "description": "[Formal Verification / Cost/Complexity](/records/tension/cost-complexity-formal-verification)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Informal Validation Only](/records/lexicon/informal-validation-only)", "term": "Violated by" }, { "description": "missing formal model for critical invariant", "term": "Detected by" }, { "description": "proven property coverage", "term": "Measured by" }, { "description": "[Formal Model](/records/lexicon/formal-model)", "term": "Refactored by" }, { "description": "proof tooling", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function transferFoo(a: FooBalance, b: FooBalance, amount: number) {\n a.value -= amount;\n b.value += amount;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function transferFoo(state: FooState, amount: PositiveAmount): FooState {\n requires(state.from >= amount.value);\n const next = { from: state.from - amount.value, to: state.to + amount.value };\n ensures(next.from + next.to === state.from + state.to);\n return next;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "proof tooling", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Formal Specification](/records/lexicon/formal-specification), [Correctness](/records/architecture/correctness), [Mathematical Assurance](/records/lexicon/mathematical-assurance)", "term": "Depends on" }, { "description": "[Informal Validation Only](/records/lexicon/informal-validation-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-formal-verification", "title": "Formal Verification" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, API, module", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of deriving tests from a specification's stated behavior, independently of how the code implements it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Specification](/records/lexicon/specification)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Contracts](/records/lexicon/contracts)", "term": "Reinforces" }, { "description": "[Behavior Validation](/records/lexicon/behavior-validation)", "term": "Enables" }, { "description": "[Spec Maintenance](/records/lexicon/spec-maintenance)", "term": "In tension with" }, { "description": "[Implementation-Only Testing](/records/lexicon/implementation-only-testing), [Mock Mirage](/records/architecture/mock-mirage)", "term": "Conflicts with" }, { "description": "[Test Coverage Kernel](/records/algorithms/test-coverage-kernel)", "term": "Contracts" }, { "description": "[Specification-Based Testing / Spec Maintenance](/records/tension/spec-maintenance-specification-based-testing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implementation-Only Testing](/records/lexicon/implementation-only-testing)", "term": "Violated by" }, { "description": "lack of spec-derived tests", "term": "Detected by" }, { "description": "spec coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "test gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "test(\"saveFoo\", async () => expect(await saveFoo(foo)).toBeTruthy());", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "describeContract(\"FooStore\", store => {\n it(\"returns the saved Foo\", async () => {\n await store.save(foo);\n expect(await store.find(foo.id)).toEqual(foo);\n });\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "test gates", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Specification](/records/lexicon/specification), [Correctness](/records/architecture/correctness), [Contracts](/records/lexicon/contracts), [Behavior Validation](/records/lexicon/behavior-validation)", "term": "Depends on" }, { "description": "[Implementation-Only Testing](/records/lexicon/implementation-only-testing), [Mock Mirage](/records/architecture/mock-mirage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-specification-based-testing", "title": "Specification-Based Testing" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, algorithm, parser, domain invariant", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of checking that a stated property holds for many generated inputs, and shrinking each failure to a minimal counterexample.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Properties/Invariants](/records/lexicon/properties-invariants)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Robustness](/records/lexicon/robustness)", "term": "Reinforces" }, { "description": "[Broad Input Exploration](/records/lexicon/broad-input-exploration)", "term": "Enables" }, { "description": "[Shrinking/Debug Complexity](/records/lexicon/shrinking-debug-complexity)", "term": "In tension with" }, { "description": "[Example-Only Testing](/records/lexicon/example-only-testing)", "term": "Conflicts with" }, { "description": "[Property-Based Testing / Shrinking/Debug Complexity](/records/tension/property-based-testing-shrinking-debug-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Example-Only Testing](/records/lexicon/example-only-testing)", "term": "Violated by" }, { "description": "missing generative tests for critical properties", "term": "Detected by" }, { "description": "property coverage, counterexample count", "term": "Measured by" }, { "description": "[Code Generation](/records/lexicon/code-generation)", "term": "Refactored by" }, { "description": "property test suite", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "test(\"normalizeFoo\", () => expect(normalizeFoo({ name: \" Foo \" }).name).toBe(\"Foo\"));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "property(string(), name => {\n const once = normalizeFoo({ name });\n const twice = normalizeFoo(once);\n expect(twice).toEqual(once);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "property test suite", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Properties/Invariants](/records/lexicon/properties-invariants), [Correctness](/records/architecture/correctness), [Robustness](/records/lexicon/robustness), [Broad Input Exploration](/records/lexicon/broad-input-exploration)", "term": "Depends on" }, { "description": "[Example-Only Testing](/records/lexicon/example-only-testing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-property-based-testing", "title": "Property-Based Testing" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: codebase, build", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that checks source code against a ruleset without running it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ruleset](/records/lexicon/ruleset)", "term": "Requires" }, { "description": "[Type Safety](/records/architecture/type-safety), [Security](/records/lexicon/security), [Architecture Compliance](/records/lexicon/architecture-compliance)", "term": "Reinforces" }, { "description": "[Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Enables" }, { "description": "[False Positives](/records/lexicon/false-positives)", "term": "In tension with" }, { "description": "[Unchecked Dynamic Code](/records/lexicon/unchecked-dynamic-code)", "term": "Conflicts with" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Metaprogramming](/records/architecture/metaprogramming), [Reflection](/records/architecture/reflection), [Plugin Architecture](/records/architecture/plugin-architecture), [Type Safety](/records/architecture/type-safety)", "term": "Referenced by" }, { "description": "[Static Analysis / False Positives](/records/tension/false-positives-static-analysis)", "term": "Tensions" }, { "description": "[Type Safety](/records/architecture/type-safety): Static analysis checks source against any ruleset, while type safety is the compiler rejecting operations on values of the wrong type.", "term": "Distinct from" }, { "description": "[Automated Enforcement](/records/lexicon/automated-enforcement): Static analysis is one way to check source without running it, while automated enforcement is any machine check that rules hold.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ignored Analyzer Findings](/records/lexicon/ignored-analyzer-findings)", "term": "Violated by" }, { "description": "static analysis rule failures", "term": "Detected by" }, { "description": "issue count, false-positive rate", "term": "Measured by" }, { "description": "[Automated Enforcement](/records/lexicon/automated-enforcement), [Track Rule Metrics](/records/lexicon/track-rule-metrics)", "term": "Refactored by" }, { "description": "CI quality gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo: any = loadFoo();\nfoo.nmae.toUpperCase();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo: Foo = loadFoo();\nfoo.name.toUpperCase();\nrunTypeCheck({ noImplicitAny: true, strictNullChecks: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI quality gates", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Ruleset](/records/lexicon/ruleset), [Type Safety](/records/architecture/type-safety), [Security](/records/lexicon/security), [Architecture Compliance](/records/lexicon/architecture-compliance), [Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Depends on" }, { "description": "[Unchecked Dynamic Code](/records/lexicon/unchecked-dynamic-code)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-static-analysis", "title": "Static Analysis" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, service", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which code can be tested in isolation, with its dependencies, time and randomness supplied by the test.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Low Coupling](/records/architecture/low-coupling), [Deterministic Behavior](/records/lexicon/deterministic-behavior)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Pure Functions](/records/architecture/pure-functions)", "term": "Reinforces" }, { "description": "[Regression Safety](/records/lexicon/regression-safety)", "term": "Enables" }, { "description": "[Encapsulation Extremes](/records/lexicon/encapsulation-extremes)", "term": "In tension with" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency), [Test Pyramid Inversion](/records/architecture/test-pyramid-inversion)", "term": "Conflicts with" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design), [Postconditions](/records/architecture/postconditions), [Referential Transparency](/records/architecture/referential-transparency), [Pure Functions](/records/architecture/pure-functions), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [High Cohesion](/records/architecture/high-cohesion), [Singleton Pattern](/records/architecture/singleton-pattern), [Stateless Processing](/records/architecture/stateless-processing), [Dependency Injection](/records/architecture/dependency-injection), [Service Locator Pattern](/records/architecture/service-locator-pattern), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Clean Architecture](/records/architecture/clean-architecture), [State Isolation](/records/architecture/state-isolation), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" }, { "description": "[Testability / Encapsulation Extremes](/records/tension/encapsulation-extremes-testability)", "term": "Tensions" }, { "description": "[High Cohesion](/records/architecture/high-cohesion): Testability is running code in isolation, while high cohesion is its members sharing one purpose.", "term": "Distinct from" }, { "description": "[Encapsulation Extremes](/records/lexicon/encapsulation-extremes): Testability is observing a unit in a test, while encapsulation extremes are the hiding that makes it hard to observe.", "term": "Distinct from" }, { "description": "[Explicit Dependencies](/records/lexicon/explicit-dependencies): Testability is supplying a unit's dependencies in a test, while explicit dependencies are those dependencies being visible in its signature.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Time/Randomness/Global State](/records/lexicon/hidden-time-randomness-global-state), [Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "difficult setup, excessive mocking, flaky tests", "term": "Detected by" }, { "description": "test setup complexity, coverage, flake rate", "term": "Measured by" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection), [Make Effects Explicit](/records/lexicon/make-effects-explicit)", "term": "Refactored by" }, { "description": "test gates, [architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFoo(name: string) {\n return fooDb.save({ id: crypto.randomUUID(), name, createdAt: new Date() });\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function createFoo(name: string, ids: IdSource, clock: Clock, store: FooStore) {\n return store.save({ id: ids.nextFooId(), name, createdAt: clock.now() });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "test gates, architecture review", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Deterministic Behavior](/records/lexicon/deterministic-behavior), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Pure Functions](/records/architecture/pure-functions), [Regression Safety](/records/lexicon/regression-safety)", "term": "Depends on" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency), [Test Pyramid Inversion](/records/architecture/test-pyramid-inversion)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-testability", "title": "Testability" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: input, behavior, requirement", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of checking that inputs and delivered behavior meet the acceptance criteria of their users.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Acceptance Criteria](/records/lexicon/acceptance-criteria)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Fitness for Use](/records/lexicon/fitness-for-use)", "term": "Enables" }, { "description": "[Iteration Speed](/records/lexicon/iteration-speed)", "term": "In tension with" }, { "description": "[Assumption-Driven Delivery](/records/lexicon/assumption-driven-delivery)", "term": "Conflicts with" }, { "description": "[Invariant](/records/architecture/invariant), [Correctness](/records/architecture/correctness), [Fail Fast](/records/architecture/fail-fast), [Self-Describing Structures](/records/architecture/self-describing-structures), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Canonicalization](/records/architecture/canonicalization), [Consistency](/records/architecture/consistency)", "term": "Referenced by" }, { "description": "[Validation / Iteration Speed](/records/tension/iteration-speed-validation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Assumption-Driven Delivery](/records/lexicon/assumption-driven-delivery)", "term": "Violated by" }, { "description": "missing acceptance tests", "term": "Detected by" }, { "description": "acceptance coverage", "term": "Measured by" }, { "description": "[Validate at the Boundary](/records/lexicon/validate-at-the-boundary), [Component Tests](/records/lexicon/component-tests)", "term": "Refactored by" }, { "description": "CI gates, QA policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFoo(input: any) { return fooStore.save(input); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function createFoo(input: unknown) {\n const foo = CreateFooSchema.parse(input);\n return fooStore.save(foo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI gates, QA policy", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Acceptance Criteria](/records/lexicon/acceptance-criteria), [Correctness](/records/architecture/correctness), [Fitness for Use](/records/lexicon/fitness-for-use)", "term": "Depends on" }, { "description": "[Assumption-Driven Delivery](/records/lexicon/assumption-driven-delivery)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-validation", "title": "Validation" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Correctness / Determinism / Verification](/records/architecture-category/correctness-determinism-verification)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: implementation, system", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of checking that an implementation conforms to its specification.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Specification](/records/lexicon/specification)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Specification Compliance](/records/lexicon/specification-compliance)", "term": "Enables" }, { "description": "[Cost](/records/lexicon/cost)", "term": "In tension with" }, { "description": "[Untested Implementation](/records/lexicon/untested-implementation)", "term": "Conflicts with" }, { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Referenced by" }, { "description": "[Codebase Verification Kernel](/records/algorithms/codebase-verification-kernel)", "term": "Contracts" }, { "description": "[Verification / Cost](/records/tension/cost-verification)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Untested Implementation](/records/lexicon/untested-implementation)", "term": "Violated by" }, { "description": "missing tests/static checks", "term": "Detected by" }, { "description": "verification coverage", "term": "Measured by" }, { "description": "[Unit Tests](/records/lexicon/unit-tests), [Static Analysis](/records/architecture/static-analysis)", "term": "Refactored by" }, { "description": "CI gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooStore.save(foo);\nreturn { ok: true };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await fooStore.save(foo);\nconst persisted = await fooStore.find(foo.id);\nif (!persisted || persisted.version !== foo.version) throw new Error(\"verification failed\");\nreturn { ok: true } as const;", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI gates", "term": "Checked by" }, { "description": "Every function, build and test run whose result the verification claims to hold", "term": "Population" }, { "description": "A verdict stands for the code, inputs and dependency versions it ran against, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The failing test, proof or analyzer finding fails the gate", "term": "Refusal" }, { "description": "Test, proof and analyzer results, plus reruns that show whether a result repeats", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The specification the test or proof encodes, which a result is compared against", "term": "Authoritative side" }, { "description": "[Specification](/records/lexicon/specification), [Correctness](/records/architecture/correctness), [Specification Compliance](/records/lexicon/specification-compliance)", "term": "Depends on" }, { "description": "[Untested Implementation](/records/lexicon/untested-implementation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-verification", "title": "Verification" } ], "title": "Correctness / Determinism / Verification" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_portability[\"Portability\"]\n n_platform_independence[\"Platform Independence\"]\n n_environment_parity[\"Environment Parity\"]\n n_containerization[\"Containerization\"]\n n_infrastructure_as_code[\"Infrastructure as Code\"]\n n_standards_compliance[\"Standards Compliance\"]\n n_protocol_independence[\"Protocol Independence\"]\n n_configuration_externalization[\"Configuration Externalization\"]\n n_immutable_infrastructure[\"Immutable Infrastructure\"]\n n_platform_independence --> n_portability\n n_environment_parity --> n_configuration_externalization\n n_environment_parity --> n_infrastructure_as_code\n n_containerization --> n_portability\n n_containerization --> n_environment_parity\n n_protocol_independence --> n_portability\n n_configuration_externalization --> n_portability\n n_configuration_externalization --> n_environment_parity\n n_immutable_infrastructure --> n_infrastructure_as_code\n n_immutable_infrastructure --> n_environment_parity" } ], "icon": "bi-collection", "id": "architecture-category-portability-infrastructure-deployment", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, infrastructure, runtime", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which software runs on another platform or environment without code changes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Standards](/records/lexicon/standards)", "term": "Requires" }, { "description": "[Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Platform Migration](/records/lexicon/platform-migration)", "term": "Enables" }, { "description": "[Platform Optimization](/records/lexicon/platform-optimization)", "term": "In tension with" }, { "description": "[Platform-Specific Coupling](/records/lexicon/platform-specific-coupling)", "term": "Conflicts with" }, { "description": "[Interoperability](/records/architecture/interoperability), [Platform Independence](/records/architecture/platform-independence), [Containerization](/records/architecture/containerization), [Protocol Independence](/records/architecture/protocol-independence), [Configuration Externalization](/records/architecture/configuration-externalization), [Low Coupling](/records/architecture/low-coupling), [Abstraction](/records/architecture/abstraction), [Independence](/records/architecture/independence), [Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" }, { "description": "[Portability / Platform Optimization](/records/tension/platform-optimization-portability)", "term": "Tensions" }, { "description": "[Integration](/records/lexicon/integration): Portability is running on another platform, while integration is being connected to other systems.", "term": "Distinct from" }, { "description": "[Platform Optimization](/records/lexicon/platform-optimization): Portability is running anywhere unchanged, while platform optimization is the tuning for one platform that it gives up.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Platform-Specific Coupling](/records/lexicon/platform-specific-coupling)", "term": "Violated by" }, { "description": "platform-specific imports in core", "term": "Detected by" }, { "description": "portability violation count", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Introduce Port](/records/lexicon/introduce-port)", "term": "Refactored by" }, { "description": "dependency rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const path = \"C:\\\\foo\\\\data\\\\foos.json\";\nconst processId = windowsApi.currentProcessId();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const path = join(config.dataDirectory, \"foos.json\");\nconst processId = runtime.processId();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency rules", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Standards](/records/lexicon/standards), [Replaceability](/records/architecture/replaceability), [Platform Migration](/records/lexicon/platform-migration)", "term": "Depends on" }, { "description": "[Platform-Specific Coupling](/records/lexicon/platform-specific-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-portability", "title": "Portability" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, runtime", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that portable layers reach the operating system and vendor services only through abstractions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Platform Abstraction](/records/lexicon/platform-abstraction)", "term": "Requires" }, { "description": "[Portability](/records/architecture/portability)", "term": "Reinforces" }, { "description": "[Cross-Platform Deployment](/records/lexicon/cross-platform-deployment)", "term": "Enables" }, { "description": "[Native Optimization](/records/lexicon/native-optimization)", "term": "In tension with" }, { "description": "[OS/Vendor Lock-In](/records/lexicon/os-vendor-lock-in)", "term": "Conflicts with" }, { "description": "[Platform Independence / Native Optimization](/records/tension/native-optimization-platform-independence)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[OS/Vendor Lock-In](/records/lexicon/os-vendor-lock-in)", "term": "Violated by" }, { "description": "OS-specific paths/APIs in portable layers", "term": "Detected by" }, { "description": "cross-platform test pass rate", "term": "Measured by" }, { "description": "[Introduce Port](/records/lexicon/introduce-port), [Canonicalization](/records/architecture/canonicalization)", "term": "Refactored by" }, { "description": "cross-platform CI", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) { return winRegistry.write(\"Foo\", foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooPersistence { save(foo: Foo): Promise; }\nfunction saveFoo(foo: Foo, persistence: FooPersistence) { return persistence.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "cross-platform CI", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Platform Abstraction](/records/lexicon/platform-abstraction), [Portability](/records/architecture/portability), [Cross-Platform Deployment](/records/lexicon/cross-platform-deployment)", "term": "Depends on" }, { "description": "[OS/Vendor Lock-In](/records/lexicon/os-vendor-lock-in)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-platform-independence", "title": "Platform Independence" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: dev, test, staging, production", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that development, test, staging and production run the same build, differing only in configuration.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Configuration Externalization](/records/architecture/configuration-externalization), [Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Requires" }, { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Reinforces" }, { "description": "[Reliable Deployment](/records/lexicon/reliable-deployment)", "term": "Enables" }, { "description": "[Cost](/records/lexicon/cost)", "term": "In tension with" }, { "description": "[Snowflake Environments](/records/lexicon/snowflake-environments)", "term": "Conflicts with" }, { "description": "[Containerization](/records/architecture/containerization), [Configuration Externalization](/records/architecture/configuration-externalization), [Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Referenced by" }, { "description": "[Environment Parity / Cost](/records/tension/cost-environment-parity)", "term": "Tensions" }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization): Environment parity runs the same build everywhere, while configuration externalization is how the differences are kept outside that build.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Snowflake Environments](/records/lexicon/snowflake-environments)", "term": "Violated by" }, { "description": "works-in-dev-only defects", "term": "Detected by" }, { "description": "[environment drift](/records/lexicon/environment-drift)", "term": "Measured by" }, { "description": "[Containerization](/records/architecture/containerization), [Externalize Configuration](/records/lexicon/externalize-configuration), [Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Refactored by" }, { "description": "environment drift checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (env === \"dev\") useMemoryFooStore();\nif (env === \"prod\") useSqlFooStore();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const container = buildFooImage(\"foo-app:1.0.0\");\nrunEnvironment(\"dev\", container, devConfig);\nrunEnvironment(\"prod\", container, prodConfig);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "environment drift checks", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization), [Infrastructure as Code](/records/architecture/infrastructure-as-code), [Reproducibility](/records/architecture/reproducibility), [Reliable Deployment](/records/lexicon/reliable-deployment)", "term": "Depends on" }, { "description": "[Snowflake Environments](/records/lexicon/snowflake-environments)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-environment-parity", "title": "Environment Parity" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, runtime, deployment", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that packages an application with its runtime dependencies into an image that runs the same on any host.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Image Definition](/records/lexicon/image-definition), [Externalized Config](/records/lexicon/externalized-config)", "term": "Requires" }, { "description": "[Portability](/records/architecture/portability), [Environment Parity](/records/architecture/environment-parity)", "term": "Reinforces" }, { "description": "[Repeatable Runtime Packaging](/records/lexicon/repeatable-runtime-packaging)", "term": "Enables" }, { "description": "[Image Complexity](/records/lexicon/image-complexity)", "term": "In tension with" }, { "description": "[Host-Coupled Deployment](/records/lexicon/host-coupled-deployment)", "term": "Conflicts with" }, { "description": "[Containerization / Image Complexity](/records/tension/containerization-image-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Host-Coupled Deployment](/records/lexicon/host-coupled-deployment)", "term": "Violated by" }, { "description": "manual host setup requirements", "term": "Detected by" }, { "description": "image reproducibility", "term": "Measured by" }, { "description": "[Externalize Configuration](/records/lexicon/externalize-configuration)", "term": "Refactored by" }, { "description": "image scans, build pipeline", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "installFooDependenciesOnHost();\nstartFooWithHostRuntime();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const image = containerImage({\n base: \"node:22-alpine\",\n copy: [\"dist\", \"package.json\"],\n command: [\"node\", \"dist/main.js\"],\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "image scans, build pipeline", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Image Definition](/records/lexicon/image-definition), [Externalized Config](/records/lexicon/externalized-config), [Portability](/records/architecture/portability), [Environment Parity](/records/architecture/environment-parity), [Repeatable Runtime Packaging](/records/lexicon/repeatable-runtime-packaging)", "term": "Depends on" }, { "description": "[Host-Coupled Deployment](/records/lexicon/host-coupled-deployment)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-containerization", "title": "Containerization" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: managed infrastructure", "Scope: infrastructure, deployment", "Aliases: IaC", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of declaring infrastructure in versioned files and provisioning it from them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Declarative Configuration](/records/architecture/declarative-configuration), [Version Control](/records/lexicon/version-control)", "term": "Requires" }, { "description": "[Reproducibility](/records/architecture/reproducibility), [Governance](/records/architecture/governance)", "term": "Reinforces" }, { "description": "[Automated Provisioning](/records/lexicon/automated-provisioning)", "term": "Enables" }, { "description": "[Tooling Complexity](/records/lexicon/tooling-complexity)", "term": "In tension with" }, { "description": "[Manual Infrastructure Changes](/records/lexicon/manual-infrastructure-changes)", "term": "Conflicts with" }, { "description": "[Environment Parity](/records/architecture/environment-parity), [Immutable Infrastructure](/records/architecture/immutable-infrastructure), [Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Referenced by" }, { "description": "[Infrastructure as Code / Tooling Complexity](/records/tension/infrastructure-as-code-tooling-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual Infrastructure Changes](/records/lexicon/manual-infrastructure-changes)", "term": "Violated by" }, { "description": "drift between code and live infra", "term": "Detected by" }, { "description": "drift count, IaC coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[policy-as-code](/records/architecture/policy-as-code), drift detection", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "cloudConsole.createDatabase(\"foo-prod\");\ncloudConsole.openPort(5432);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooDatabase = databaseResource({\n name: \"foo-prod\",\n engine: \"postgres\",\n encrypted: true,\n networkPolicy: \"foo-only\",\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy-as-code, drift detection", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration), [Version Control](/records/lexicon/version-control), [Reproducibility](/records/architecture/reproducibility), [Governance](/records/architecture/governance), [Automated Provisioning](/records/lexicon/automated-provisioning)", "term": "Depends on" }, { "description": "[Manual Infrastructure Changes](/records/lexicon/manual-infrastructure-changes)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-infrastructure-as-code", "title": "Infrastructure as Code" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: protocol, security, data, infrastructure", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that an implementation conforms to the published standard for its protocol, format or domain.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Applicable Standard](/records/lexicon/applicable-standard)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability), [Compliance](/records/architecture/compliance)", "term": "Reinforces" }, { "description": "[Certification/Compatibility](/records/lexicon/certification-compatibility)", "term": "Enables" }, { "description": "[Innovation/Flexibility](/records/lexicon/innovation-flexibility)", "term": "In tension with" }, { "description": "[Proprietary Deviation](/records/lexicon/proprietary-deviation)", "term": "Conflicts with" }, { "description": "[Standards Compliance / Innovation/Flexibility](/records/tension/innovation-flexibility-standards-compliance)", "term": "Tensions" }, { "description": "[Compliance](/records/architecture/compliance): Standards compliance is technical conformance to a published protocol or format, while compliance is implementing and evidencing the controls a regulation requires.", "term": "Distinct from" }, { "description": "[Applicable Standard](/records/lexicon/applicable-standard): Standards compliance is conforming, while the applicable standard is the one standard identified to conform to.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Proprietary Deviation](/records/lexicon/proprietary-deviation)", "term": "Violated by" }, { "description": "conformance test failure", "term": "Detected by" }, { "description": "standard compliance score", "term": "Measured by" }, { "description": "[Contract Testing](/records/lexicon/contract-testing)", "term": "Refactored by" }, { "description": "standards checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const payload = encodePrivateFooBinary(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const payload: JsonFooV1 = toJsonFoo(foo);\nhttp.send(JSON.stringify(payload), { contentType: \"application/json; charset=utf-8\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "standards checks", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Applicable Standard](/records/lexicon/applicable-standard), [Interoperability](/records/architecture/interoperability), [Compliance](/records/architecture/compliance), [Certification/Compatibility](/records/lexicon/certification-compatibility)", "term": "Depends on" }, { "description": "[Proprietary Deviation](/records/lexicon/proprietary-deviation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-standards-compliance", "title": "Standards Compliance" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: integration, service boundary", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that domain logic is written against ports, and each transport protocol reaches it through its own adapter.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Adapter/Port Abstraction](/records/lexicon/adapter-port-abstraction)", "term": "Requires" }, { "description": "[Portability](/records/architecture/portability), [Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Protocol Swap](/records/lexicon/protocol-swap)", "term": "Enables" }, { "description": "[Protocol-Specific Features](/records/lexicon/protocol-specific-features)", "term": "In tension with" }, { "description": "[Protocol-Coupled Domain Logic](/records/lexicon/protocol-coupled-domain-logic)", "term": "Conflicts with" }, { "description": "[Protocol Independence / Protocol-Specific Features](/records/tension/protocol-independence-protocol-specific-features)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Protocol-Coupled Domain Logic](/records/lexicon/protocol-coupled-domain-logic)", "term": "Violated by" }, { "description": "protocol imports in core layer", "term": "Detected by" }, { "description": "protocol leakage count", "term": "Measured by" }, { "description": "[Introduce Port](/records/lexicon/introduce-port), [Extract Adapter](/records/lexicon/extract-adapter)", "term": "Refactored by" }, { "description": "import rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n handleHttp(request: HttpRequest) { return fooStore.save(request.body); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class CreateFoo {\n constructor(private readonly store: FooStore) {}\n execute(input: CreateFooInput) { return this.store.save(Foo.create(input)); }\n}\nhttpAdapter.bind(createFoo);\ngrpcAdapter.bind(createFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Adapter/Port Abstraction](/records/lexicon/adapter-port-abstraction), [Portability](/records/architecture/portability), [Replaceability](/records/architecture/replaceability), [Protocol Swap](/records/lexicon/protocol-swap)", "term": "Depends on" }, { "description": "[Protocol-Coupled Domain Logic](/records/lexicon/protocol-coupled-domain-logic)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-protocol-independence", "title": "Protocol Independence" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: application, deployment, runtime", "Aliases: Externalized Configuration", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that environment-specific values are read from validated external configuration at startup.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Config Schema](/records/lexicon/config-schema), [Secure Config Handling](/records/lexicon/secure-config-handling)", "term": "Requires" }, { "description": "[Portability](/records/architecture/portability), [Environment Parity](/records/architecture/environment-parity)", "term": "Reinforces" }, { "description": "[Environment-Specific Deployment](/records/lexicon/environment-specific-deployment)", "term": "Enables" }, { "description": "[Config Sprawl](/records/lexicon/config-sprawl)", "term": "In tension with" }, { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Conflicts with" }, { "description": "[Environment Parity](/records/architecture/environment-parity)", "term": "Referenced by" }, { "description": "[Configuration Externalization / Config Sprawl](/records/tension/config-sprawl-configuration-externalization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Violated by" }, { "description": "hardcoded URLs/secrets/paths", "term": "Detected by" }, { "description": "externalized config coverage", "term": "Measured by" }, { "description": "[Externalize Configuration](/records/lexicon/externalize-configuration), [Validate at the Boundary](/records/lexicon/validate-at-the-boundary)", "term": "Refactored by" }, { "description": "secret/config scans", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const config = {\n fooUrl: \"https://foo.prod.example\",\n retries: 3,\n};", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooConfig = Readonly<{ fooUrl: URL; retries: number }>;\nconst config = FooConfigSchema.parse({\n fooUrl: process.env.FOO_URL,\n retries: process.env.FOO_RETRIES,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "secret/config scans", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Config Schema](/records/lexicon/config-schema), [Secure Config Handling](/records/lexicon/secure-config-handling), [Portability](/records/architecture/portability), [Environment Parity](/records/architecture/environment-parity), [Environment-Specific Deployment](/records/lexicon/environment-specific-deployment)", "term": "Depends on" }, { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-configuration-externalization", "title": "Configuration Externalization" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Portability / Infrastructure / Deployment](/records/architecture-category/portability-infrastructure-deployment)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: managed infrastructure", "Scope: infrastructure, deployment, reproducibility", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which servers are replaced from a new image for every change, instead of being patched in place.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Requires" }, { "description": "[Environment Parity](/records/architecture/environment-parity), [Reproducibility](/records/architecture/reproducibility)", "term": "Reinforces" }, { "description": "[Deterministic Redeploys](/records/lexicon/deterministic-redeploys), [Instance Replacement over Mutation](/records/lexicon/instance-replacement-over-mutation)", "term": "Enables" }, { "description": "[Deploy Time](/records/lexicon/deploy-time)", "term": "In tension with" }, { "description": "[In-Place Server Mutation](/records/lexicon/in-place-server-mutation)", "term": "Conflicts with" }, { "description": "[Immutable Infrastructure / Deploy Time](/records/tension/deploy-time-immutable-infrastructure)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[In-Place Server Mutation](/records/lexicon/in-place-server-mutation)", "term": "Violated by" }, { "description": "SSH mutation of live instances", "term": "Detected by" }, { "description": "config drift across instances", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "deployment review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "ssh(server, \"apt-get update && systemctl restart foo\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const image = buildFooImage(\"foo:1.4.0\");\nreplaceInstances(\"foo\", image);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment review", "term": "Checked by" }, { "description": "Every platform call, environment, configuration value and infrastructure resource the deployment uses", "term": "Population" }, { "description": "A verdict stands until the code, the image, the configuration or the live infrastructure changes", "term": "Freshness" }, { "description": "The import rule, config scan or drift detection fails the change or the deploy", "term": "Refusal" }, { "description": "Platform imports read from source, and the declared infrastructure compared with the live state", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared infrastructure, which the live state is compared against", "term": "Authoritative side" }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code), [Environment Parity](/records/architecture/environment-parity), [Reproducibility](/records/architecture/reproducibility), [Deterministic Redeploys](/records/lexicon/deterministic-redeploys), [Instance Replacement over Mutation](/records/lexicon/instance-replacement-over-mutation)", "term": "Depends on" }, { "description": "[In-Place Server Mutation](/records/lexicon/in-place-server-mutation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-immutable-infrastructure", "title": "Immutable Infrastructure" } ], "title": "Portability / Infrastructure / Deployment" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_single_responsibility[\"Single Responsibility Principle (SRP)\"]\n n_separation_of_concerns[\"Separation of Concerns\"]\n n_duplicate_code[\"Do Not Repeat Yourself (DRY)\"]\n n_high_cohesion[\"High Cohesion\"]\n n_low_coupling[\"Low Coupling\"]\n n_encapsulation[\"Encapsulation\"]\n n_information_hiding[\"Information Hiding\"]\n n_abstraction[\"Abstraction\"]\n n_modularity[\"Modularity\"]\n n_composability[\"Composability\"]\n n_composition_over_inheritance[\"Composition Over Inheritance\"]\n n_reusability[\"Reusability\"]\n n_replaceability[\"Replaceability\"]\n n_interchangeability[\"Interchangeability\"]\n n_independence[\"Independence\"]\n n_autonomy[\"Autonomy\"]\n n_single_responsibility --> n_high_cohesion\n n_single_responsibility --> n_separation_of_concerns\n n_single_responsibility --> n_modularity\n n_single_responsibility --> n_replaceability\n n_single_responsibility --> n_reusability\n n_separation_of_concerns --> n_abstraction\n n_separation_of_concerns --> n_single_responsibility\n n_separation_of_concerns --> n_modularity\n n_separation_of_concerns --> n_replaceability\n n_duplicate_code --> n_abstraction\n n_duplicate_code --> n_reusability\n n_high_cohesion --> n_single_responsibility\n n_high_cohesion --> n_modularity\n n_high_cohesion --> n_encapsulation\n n_high_cohesion --> n_replaceability\n n_low_coupling --> n_abstraction\n n_low_coupling --> n_modularity\n n_low_coupling --> n_replaceability\n n_encapsulation --> n_information_hiding\n n_encapsulation --> n_abstraction\n n_encapsulation --> n_low_coupling\n n_information_hiding --> n_encapsulation\n n_information_hiding --> n_low_coupling\n n_information_hiding --> n_replaceability\n n_abstraction --> n_low_coupling\n n_abstraction --> n_replaceability\n n_modularity --> n_high_cohesion\n n_modularity --> n_low_coupling\n n_modularity --> n_separation_of_concerns\n n_modularity --> n_composability\n n_modularity --> n_replaceability\n n_composability --> n_low_coupling\n n_composability --> n_modularity\n n_composability --> n_reusability\n n_composition_over_inheritance --> n_low_coupling\n n_composition_over_inheritance --> n_replaceability\n n_reusability --> n_abstraction\n n_reusability --> n_duplicate_code\n n_reusability --> n_composability\n n_replaceability --> n_low_coupling\n n_interchangeability --> n_replaceability\n n_independence --> n_low_coupling\n n_independence --> n_autonomy\n n_autonomy --> n_independence" } ], "icon": "bi-collection", "id": "architecture-category-core-modular-design", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, service", "Aliases: SRP, Single Responsibility Principle", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a class or module has one reason to change, because it serves one responsibility.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[High Cohesion](/records/architecture/high-cohesion), [Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Requires" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns), [Modularity](/records/architecture/modularity), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Replaceability](/records/architecture/replaceability), [Reusability](/records/architecture/reusability)", "term": "Enables" }, { "description": "[Excessive Fragmentation](/records/lexicon/excessive-fragmentation)", "term": "In tension with" }, { "description": "[God Object](/records/architecture/god-object), [Divergent Change](/records/architecture/divergent-change)", "term": "Conflicts with" }, { "description": "[Domain Service](/records/architecture/domain-service), [Separation of Concerns](/records/architecture/separation-of-concerns), [High Cohesion](/records/architecture/high-cohesion), [Interface Segregation Principle (ISP)](/records/architecture/interface-segregation), [Command Pattern](/records/architecture/command-pattern), [Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern), [Iterator Pattern](/records/architecture/iterator-pattern), [Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" }, { "description": "[Single Responsibility Principle (SRP) / Excessive Fragmentation](/records/tension/excessive-fragmentation-single-responsibility-principle-srp)", "term": "Tensions" }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation): Single responsibility limits a module's reasons to change, while interface segregation limits what a client depends on.", "term": "Distinct from" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed): Single responsibility limits reasons to change, while the open/closed principle governs adding behavior without editing.", "term": "Distinct from" }, { "description": "[Composability](/records/architecture/composability): Single responsibility limits what one part does, while composability governs how parts combine.", "term": "Distinct from" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns): Single responsibility is one reason to change per class or module, while separation of concerns separates the named concerns of a system.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[God Object](/records/architecture/god-object), [Divergent Change](/records/architecture/divergent-change)", "term": "Violated by" }, { "description": "high fan-in/fan-out, unrelated methods, unrelated dependencies", "term": "Detected by" }, { "description": "cohesion score, responsibility count, change-coupling", "term": "Measured by" }, { "description": "[Extract Class](/records/lexicon/extract-class), [Extract Module](/records/lexicon/extract-module), [Split Bounded Context](/records/lexicon/split-bounded-context), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner)", "term": "Refactored by" }, { "description": "architecture tests, package boundaries, [static analysis](/records/reasoning/technique-static-analysis)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n save(foo: Foo) { fooDb.insert(foo); }\n send(foo: Foo) { fooMail.send(foo); }\n report(foo: Foo) { return `${foo.id}:${foo.name}`; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooRepository { save(foo: Foo) { return fooDb.insert(foo); } }\nclass FooNotifier { send(foo: Foo) { return fooMail.send(foo); } }\nclass FooReporter { report(foo: Foo) { return `${foo.id}:${foo.name}`; } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests, package boundaries, static analysis", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[High Cohesion](/records/architecture/high-cohesion), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Separation of Concerns](/records/architecture/separation-of-concerns), [Modularity](/records/architecture/modularity), [Testability](/records/architecture/testability), [Replaceability](/records/architecture/replaceability), [Reusability](/records/architecture/reusability)", "term": "Depends on" }, { "description": "[God Object](/records/architecture/god-object), [God Object](/records/architecture/god-object), [Divergent Change](/records/architecture/divergent-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-single-responsibility", "title": "Single Responsibility Principle (SRP)" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: module, package, component, system", "Aliases: SoC", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that parsing, business logic, persistence and presentation each live in their own part of the code.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Abstraction](/records/architecture/abstraction)", "term": "Requires" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Modularity](/records/architecture/modularity), [Layered Architecture](/records/architecture/layered-architecture)", "term": "Reinforces" }, { "description": "[Maintainability](/records/lexicon/maintainability), [Replaceability](/records/architecture/replaceability)", "term": "Enables" }, { "description": "[Over-Layering](/records/lexicon/over-layering)", "term": "In tension with" }, { "description": "[Cross-Cutting Leakage](/records/lexicon/cross-cutting-leakage), [Mixed Layers](/records/lexicon/mixed-layers)", "term": "Conflicts with" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Modularity](/records/architecture/modularity), [Visitor Pattern](/records/architecture/visitor-pattern), [Statecharts](/records/architecture/statecharts), [Layered Architecture](/records/architecture/layered-architecture), [One Concern Per File](/records/architecture/one-concern-per-file)", "term": "Referenced by" }, { "description": "[Separation of Concerns / Over-Layering](/records/tension/over-layering-separation-of-concerns)", "term": "Tensions" }, { "description": "[One Concern Per File](/records/architecture/one-concern-per-file): Separation of concerns splits code by responsibility, while one concern per file binds each file to one declared role tag.", "term": "Distinct from" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed): Separation of concerns decides where concerns live, while the open/closed principle decides how behavior is added.", "term": "Distinct from" }, { "description": "[Composability](/records/architecture/composability): Separation of concerns keeps concerns apart, while composability lets parts combine.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Mixed Layers](/records/lexicon/mixed-layers)", "term": "Violated by" }, { "description": "layer imports, mixed naming roles, cross-boundary logic", "term": "Detected by" }, { "description": "dependency direction, layer purity, concern overlap", "term": "Measured by" }, { "description": "[Extract Module](/records/lexicon/extract-module), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Define Module Boundaries](/records/lexicon/define-module-boundaries)", "term": "Refactored by" }, { "description": "import rules, dependency graph checks", "term": "Enforced by" }, { "description": "separation-of-concerns", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function handleFoo(request: Request) {\n const foo = JSON.parse(request.body);\n fooDb.insert(foo);\n return `
${foo.name}`;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function parseFoo(request: Request): Foo { return decodeFoo(request.body); }\nfunction saveFoo(foo: Foo) { return fooDb.insert(foo); }\nfunction renderFoo(foo: Foo) { return `
${foo.name}`; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import rules, dependency graph checks", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Abstraction](/records/architecture/abstraction), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Modularity](/records/architecture/modularity), [Layered Architecture](/records/architecture/layered-architecture), [Maintainability](/records/lexicon/maintainability), [Replaceability](/records/architecture/replaceability)", "term": "Depends on" }, { "description": "[Cross-Cutting Leakage](/records/lexicon/cross-cutting-leakage), [Mixed Layers](/records/lexicon/mixed-layers)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-separation-of-concerns", "title": "Separation of Concerns" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, module, domain", "Aliases: DRY, Do Not Repeat Yourself, Don't Repeat Yourself", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each piece of logic, constant or schema has one source in the code, and every other use refers to it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Canonical Source](/records/lexicon/canonical-source)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Reusability](/records/architecture/reusability)", "term": "Reinforces" }, { "description": "[Consistency](/records/architecture/consistency), [Maintainability](/records/lexicon/maintainability)", "term": "Enables" }, { "description": "[Locality of Behavior](/records/lexicon/locality-of-behavior), [Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Copy-Paste Programming](/records/lexicon/copy-paste-programming)", "term": "Conflicts with" }, { "description": "[Reusability](/records/architecture/reusability), [Metaprogramming](/records/architecture/metaprogramming), [Single Source of Truth](/records/architecture/single-source-of-truth), [Normalization](/records/architecture/normalization)", "term": "Referenced by" }, { "description": "[Do Not Repeat Yourself (DRY) / Locality of Behavior](/records/tension/do-not-repeat-yourself-dry-locality-of-behavior), [Do Not Repeat Yourself (DRY) / Simplicity](/records/tension/do-not-repeat-yourself-dry-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Copy-Paste Programming](/records/lexicon/copy-paste-programming)", "term": "Violated by" }, { "description": "clone detection, duplicated branches, repeated literals", "term": "Detected by" }, { "description": "duplication percentage, clone count", "term": "Measured by" }, { "description": "[Extract Function](/records/lexicon/extract-function), [Extract Module](/records/lexicon/extract-module), [Introduce Parameter Object](/records/lexicon/introduce-parameter-object), [Centralize the Rule](/records/lexicon/centralize-the-rule)", "term": "Refactored by" }, { "description": "clone analyzers, lint rules, review gates", "term": "Enforced by" }, { "description": "duplicate-code", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function validateFoo(foo: Foo) {\n if (!foo.name || foo.name.length > 40) throw new Error(\"invalid name\");\n}\nfunction validateBar(bar: Bar) {\n if (!bar.name || bar.name.length > 40) throw new Error(\"invalid name\");\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function validateName(name: string) {\n if (!name || name.length > 40) throw new Error(\"invalid name\");\n}\nfunction validateFoo(foo: Foo) { validateName(foo.name); }\nfunction validateBar(bar: Bar) { validateName(bar.name); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "clone analyzers, lint rules, review gates", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Canonical Source](/records/lexicon/canonical-source), [Single Source of Truth](/records/architecture/single-source-of-truth), [Reusability](/records/architecture/reusability), [Consistency](/records/architecture/consistency), [Maintainability](/records/lexicon/maintainability)", "term": "Depends on" }, { "description": "[Copy-Paste Programming](/records/lexicon/copy-paste-programming)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-duplicate-code", "title": "Do Not Repeat Yourself (DRY)" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, component", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the members of a class or module work on the same data towards the same purpose.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Testability](/records/architecture/testability), [Replaceability](/records/architecture/replaceability)", "term": "Enables" }, { "description": "[Over-Specialization](/records/lexicon/over-specialization)", "term": "In tension with" }, { "description": "[God Object](/records/architecture/god-object), [Utility Dump](/records/architecture/utility-dump), [Shotgun Surgery](/records/architecture/shotgun-surgery)", "term": "Conflicts with" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Modularity](/records/architecture/modularity)", "term": "Referenced by" }, { "description": "[High Cohesion / Over-Specialization](/records/tension/high-cohesion-over-specialization)", "term": "Tensions" }, { "description": "[Over-Specialization](/records/lexicon/over-specialization): High cohesion is members sharing one purpose, while over-specialization is the reuse lost by narrowing that purpose too far.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Divergent Change](/records/architecture/divergent-change)", "term": "Violated by" }, { "description": "low LCOM, scattered dependencies, unrelated public API", "term": "Detected by" }, { "description": "cohesion metrics, change locality", "term": "Measured by" }, { "description": "[Extract Class](/records/lexicon/extract-class), [Split Module](/records/lexicon/split-module), [Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner)", "term": "Refactored by" }, { "description": "module ownership, [architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooManager {\n saveFoo(foo: Foo) { return fooDb.insert(foo); }\n resizeImage(image: Image) { return image.resize(100, 100); }\n parseBar(raw: string) { return JSON.parse(raw) as Bar; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooRepository {\n save(foo: Foo) { return fooDb.insert(foo); }\n load(id: FooId) { return fooDb.find(id); }\n remove(id: FooId) { return fooDb.delete(id); }\n}\nclass ImageResizer { resize(image: Image) { return image.resize(100, 100); } }\nclass BarParser { parse(raw: string) { return JSON.parse(raw) as Bar; } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "module ownership, architecture review", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Modularity](/records/architecture/modularity), [Encapsulation](/records/architecture/encapsulation), [Testability](/records/architecture/testability), [Replaceability](/records/architecture/replaceability)", "term": "Depends on" }, { "description": "[God Object](/records/architecture/god-object), [Utility Dump](/records/architecture/utility-dump), [Shotgun Surgery](/records/architecture/shotgun-surgery)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-high-cohesion", "title": "High Cohesion" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: module, component, service", "Aliases: Loose Coupling, Decoupling", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a module can change without forcing changes in the modules around it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Replaceability](/records/architecture/replaceability), [Portability](/records/architecture/portability)", "term": "Reinforces" }, { "description": "[Independent Deployment](/records/lexicon/independent-deployment), [Independent Testing](/records/lexicon/independent-testing)", "term": "Enables" }, { "description": "[Runtime Indirection](/records/lexicon/runtime-indirection)", "term": "In tension with" }, { "description": "[Tight Coupling](/records/lexicon/tight-coupling), [Circular Dependency](/records/architecture/circular-dependency), [Inappropriate Intimacy](/records/architecture/inappropriate-intimacy), [Message Chain](/records/architecture/message-chain)", "term": "Conflicts with" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Stable Interfaces](/records/architecture/stable-interfaces), [Testability](/records/architecture/testability), [Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding), [Abstraction](/records/architecture/abstraction), [Modularity](/records/architecture/modularity), [Composability](/records/architecture/composability), [Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Replaceability](/records/architecture/replaceability), [Independence](/records/architecture/independence), [Interface Segregation Principle (ISP)](/records/architecture/interface-segregation), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Message Broker](/records/architecture/message-broker), [Asynchronous Communication](/records/architecture/asynchronous-communication), [Mediator Pattern](/records/architecture/mediator-pattern), [Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" }, { "description": "[Low Coupling / Runtime Indirection](/records/tension/low-coupling-runtime-indirection)", "term": "Tensions" }, { "description": "[High Cohesion](/records/architecture/high-cohesion): Low coupling is about the dependencies between modules, while high cohesion is about the purpose inside one.", "term": "Distinct from" }, { "description": "[Portability](/records/architecture/portability): Low coupling limits how far a change ripples between modules, while portability is running on another platform unchanged.", "term": "Distinct from" }, { "description": "[Replaceability](/records/architecture/replaceability): Low coupling limits how far a change spreads, while replaceability is swapping an implementation without editing its callers.", "term": "Distinct from" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces): Low coupling is few forced changes between modules, while stable interfaces are signatures that keep across releases.", "term": "Distinct from" }, { "description": "[Testability](/records/architecture/testability): Low coupling concerns change between modules, while testability is running code in isolation with supplied dependencies.", "term": "Distinct from" }, { "description": "[Domain Purity](/records/lexicon/domain-purity): Low coupling applies between any modules, while domain purity keeps the domain model free of infrastructure concerns.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Tight Coupling](/records/lexicon/tight-coupling), [Circular Dependency](/records/architecture/circular-dependency)", "term": "Violated by" }, { "description": "dependency cycles, high afferent/efferent coupling", "term": "Detected by" }, { "description": "coupling metrics, dependency graph density", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface), [Dependency Injection](/records/architecture/dependency-injection), [Extract Adapter](/records/lexicon/extract-adapter)", "term": "Refactored by" }, { "description": "dependency rules, architecture fitness tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n save(foo: Foo) {\n const db = new SqlDatabase(\"foo-prod\");\n barIndex.update(foo);\n return db.table(\"foos\").insert(foo);\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {\n constructor(private readonly events: EventSink) {}\n save(foo: Foo) { return this.events.emit({ type: \"FooSaved\", foo }); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency rules, architecture fitness tests", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces), [Modularity](/records/architecture/modularity), [Replaceability](/records/architecture/replaceability), [Portability](/records/architecture/portability), [Independent Deployment](/records/lexicon/independent-deployment), [Independent Testing](/records/lexicon/independent-testing)", "term": "Depends on" }, { "description": "[Tight Coupling](/records/lexicon/tight-coupling), [Circular Dependency](/records/architecture/circular-dependency), [Inappropriate Intimacy](/records/architecture/inappropriate-intimacy), [Message Chain](/records/architecture/message-chain)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-low-coupling", "title": "Low Coupling" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, component", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an object's state is changed only through its own operations, which keep its invariants.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Information Hiding](/records/architecture/information-hiding), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Abstraction](/records/architecture/abstraction), [Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Change Isolation](/records/lexicon/change-isolation), [Invariant Protection](/records/lexicon/invariant-protection)", "term": "Enables" }, { "description": "[Debuggability](/records/lexicon/debuggability)", "term": "In tension with" }, { "description": "[Exposed Internals](/records/lexicon/exposed-internals), [Exposed Internals](/records/lexicon/exposed-internals), [Feature Envy](/records/architecture/feature-envy)", "term": "Conflicts with" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Aggregate](/records/architecture/aggregate), [Value Object](/records/architecture/value-object), [Entity](/records/architecture/entity), [Invariant](/records/architecture/invariant), [High Cohesion](/records/architecture/high-cohesion), [Information Hiding](/records/architecture/information-hiding), [Introspection](/records/architecture/introspection), [Command Pattern](/records/architecture/command-pattern), [Iterator Pattern](/records/architecture/iterator-pattern), [Memento Pattern](/records/architecture/memento-pattern), [Factory Pattern](/records/architecture/factory-pattern), [Facade Pattern](/records/architecture/facade-pattern), [Proxy Pattern](/records/architecture/proxy-pattern), [State Isolation](/records/architecture/state-isolation)", "term": "Referenced by" }, { "description": "[Encapsulation / Debuggability](/records/tension/debuggability-encapsulation)", "term": "Tensions" }, { "description": "[Abstraction](/records/architecture/abstraction): Encapsulation guards an object's state behind its operations, while abstraction expresses what a thing does without how.", "term": "Distinct from" }, { "description": "[Information Hiding](/records/architecture/information-hiding): Encapsulation protects state and its invariants, while information hiding keeps implementation decisions private behind an interface.", "term": "Distinct from" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility): Encapsulation guards state, while single responsibility limits a module to one reason to change.", "term": "Distinct from" }, { "description": "[Immutability](/records/architecture/immutability): Encapsulation controls how state changes, while immutability forbids change after creation.", "term": "Distinct from" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed): Encapsulation protects existing state, while the open/closed principle governs how new behavior is added.", "term": "Distinct from" }, { "description": "[State Isolation](/records/architecture/state-isolation): Encapsulation limits writes to an object's own operations, while state isolation limits writes to one unit of concurrent execution.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exposed Internals](/records/lexicon/exposed-internals), [Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Violated by" }, { "description": "public state, excessive setters, external invariant manipulation", "term": "Detected by" }, { "description": "public surface area, mutation exposure", "term": "Measured by" }, { "description": "[Encapsulate State](/records/lexicon/encapsulate-state), [Extract Function](/records/lexicon/extract-function), [Restrict Exports](/records/lexicon/restrict-exports)", "term": "Refactored by" }, { "description": "visibility rules, linting, API review", "term": "Enforced by" }, { "description": "encapsulation", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "class FooCounter {\n count = 0;\n}\nconst counter = new FooCounter();\ncounter.count = -100;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooCounter {\n #count = 0;\n increment() { this.#count += 1; }\n value() { return this.#count; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "visibility rules, linting, API review", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Information Hiding](/records/architecture/information-hiding), [Stable Interfaces](/records/architecture/stable-interfaces), [Abstraction](/records/architecture/abstraction), [Low Coupling](/records/architecture/low-coupling), [Change Isolation](/records/lexicon/change-isolation), [Invariant Protection](/records/lexicon/invariant-protection)", "term": "Depends on" }, { "description": "[Exposed Internals](/records/lexicon/exposed-internals), [Exposed Internals](/records/lexicon/exposed-internals), [Feature Envy](/records/architecture/feature-envy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-encapsulation", "title": "Encapsulation" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, package", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a module exposes an interface and keeps the implementation decisions behind it private.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation), [Explicit Interfaces](/records/lexicon/explicit-interfaces)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Internal Refactoring](/records/lexicon/internal-refactoring)", "term": "Enables" }, { "description": "[Observability](/records/architecture/observability)", "term": "In tension with" }, { "description": "[Leaky Abstraction](/records/lexicon/leaky-abstraction)", "term": "Conflicts with" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Memento Pattern](/records/architecture/memento-pattern), [Facade Pattern](/records/architecture/facade-pattern)", "term": "Referenced by" }, { "description": "[Information Hiding / Observability](/records/tension/information-hiding-observability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Leaky Abstraction](/records/lexicon/leaky-abstraction), [Exposed Internals](/records/lexicon/exposed-internals)", "term": "Violated by" }, { "description": "internal packages imported externally, exposed persistence models", "term": "Detected by" }, { "description": "internal API exposure, dependency leakage", "term": "Measured by" }, { "description": "[Facade Pattern](/records/architecture/facade-pattern), [Restrict Exports](/records/lexicon/restrict-exports)", "term": "Refactored by" }, { "description": "package visibility, module export rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooStore {\n public readonly rows = new Map();\n}\nfooStore.rows.set(foo.id, foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooStore {\n save(foo: Foo): void;\n find(id: string): Foo | undefined;\n}\nclass MapFooStore implements FooStore {\n #rows = new Map();\n save(foo: Foo) { this.#rows.set(foo.id, foo); }\n find(id: string) { return this.#rows.get(id); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "package visibility, module export rules", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Explicit Interfaces](/records/lexicon/explicit-interfaces), [Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability), [Internal Refactoring](/records/lexicon/internal-refactoring)", "term": "Depends on" }, { "description": "[Leaky Abstraction](/records/lexicon/leaky-abstraction)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-information-hiding", "title": "Information Hiding" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, module, service, system", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a concept is expressed by what it does for the code that uses it, and the detail of how it does it stays out of that expression.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Semantics](/records/lexicon/stable-semantics), [Interface Definition](/records/lexicon/interface-definition)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Low Coupling](/records/architecture/low-coupling), [Portability](/records/architecture/portability)", "term": "Reinforces" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Replaceability](/records/architecture/replaceability)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Middle Man](/records/architecture/middle-man)", "term": "Conflicts with" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Interface-Based Design](/records/architecture/interface-based-design), [Portability](/records/architecture/portability), [Separation of Concerns](/records/architecture/separation-of-concerns), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Low Coupling](/records/architecture/low-coupling), [Encapsulation](/records/architecture/encapsulation), [Reusability](/records/architecture/reusability), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism), [Inversion of Control (IoC)](/records/architecture/inversion-of-control), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" }, { "description": "[Abstraction / Simplicity](/records/tension/abstraction-simplicity)", "term": "Tensions" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion): Abstraction expresses a concept by what it does, while dependency inversion fixes that the high-level policy owns that expression.", "term": "Distinct from" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code): Abstraction hides how a thing works behind what it does, while DRY keeps one source for each piece of logic.", "term": "Distinct from" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design): Abstraction is the general rule, while interface-based design applies it to module dependencies supplied from outside.", "term": "Distinct from" }, { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control): Abstraction hides detail, while inversion of control moves object creation and control flow to a framework or composition root.", "term": "Distinct from" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed): Abstraction hides detail, while the open/closed principle adds behavior at an extension point without editing existing code.", "term": "Distinct from" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns): Abstraction separates what from how, while separation of concerns separates parsing, logic, persistence and presentation.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Leaky Abstraction](/records/lexicon/leaky-abstraction), [Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Violated by" }, { "description": "concrete type usage across boundaries", "term": "Detected by" }, { "description": "abstraction ratio, interface stability", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface), [Introduce Port](/records/lexicon/introduce-port), [Invert Dependency](/records/lexicon/invert-dependency)", "term": "Refactored by" }, { "description": "architecture tests, dependency inversion rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) {\n return sqlClient.query(\"insert into foos(id,name) values($1,$2)\", [foo.id, foo.name]);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooRepository { save(foo: Foo): Promise; }\nclass SqlFooRepository implements FooRepository {\n save(foo: Foo) { return sqlClient.query(\"insert into foos(id,name) values($1,$2)\", [foo.id, foo.name]); }\n}\nclass HttpFooRepository implements FooRepository {\n save(foo: Foo) { return http.post(\"/foos\", foo); }\n}\nfunction saveFoo(foo: Foo, repository: FooRepository) { return repository.save(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests, dependency inversion rules", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Stable Semantics](/records/lexicon/stable-semantics), [Interface Definition](/records/lexicon/interface-definition), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Low Coupling](/records/architecture/low-coupling), [Portability](/records/architecture/portability), [Polymorphism](/records/architecture/polymorphism), [Replaceability](/records/architecture/replaceability)", "term": "Depends on" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Middle Man](/records/architecture/middle-man)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-abstraction", "title": "Abstraction" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: package, component, service, system", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a system is divided into cohesive modules with explicit boundaries and few dependencies between them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[High Cohesion](/records/architecture/high-cohesion), [Low Coupling](/records/architecture/low-coupling), [Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Requires" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns), [Composability](/records/architecture/composability)", "term": "Reinforces" }, { "description": "[Replaceability](/records/architecture/replaceability), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Enables" }, { "description": "[Cross-Cutting Concerns](/records/lexicon/cross-cutting-concerns)", "term": "In tension with" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Conflicts with" }, { "description": "[Bounded Context](/records/architecture/bounded-context), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Separation of Concerns](/records/architecture/separation-of-concerns), [High Cohesion](/records/architecture/high-cohesion), [Low Coupling](/records/architecture/low-coupling), [Composability](/records/architecture/composability), [Plugin Architecture](/records/architecture/plugin-architecture), [Component-Based Architecture](/records/architecture/component-based-architecture), [Package by Feature](/records/architecture/package-by-feature)", "term": "Referenced by" }, { "description": "[Modularity / Cross-Cutting Concerns](/records/tension/cross-cutting-concerns-modularity)", "term": "Tensions" }, { "description": "[Autonomy](/records/architecture/autonomy): Modularity divides a system into cohesive parts, while autonomy gives each owner its own data and decisions.", "term": "Distinct from" }, { "description": "[Composability](/records/architecture/composability): Modularity divides a system, while composability lets its parts combine.", "term": "Distinct from" }, { "description": "[Encapsulation](/records/architecture/encapsulation): Modularity is division into modules, while encapsulation protects one object's state.", "term": "Distinct from" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed): Modularity divides the system, while the open/closed principle governs adding behavior at an extension point.", "term": "Distinct from" }, { "description": "[Package by Feature](/records/architecture/package-by-feature): Modularity is the rule to divide, while package by feature chooses the axis of division, the feature.", "term": "Distinct from" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns): Modularity divides into cohesive modules, while separation of concerns names which concerns must not share a part.", "term": "Distinct from" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility): Modularity is the division of a system, while single responsibility limits one class or module to one reason to change.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Circular Dependency](/records/architecture/circular-dependency), [Shared Mutable State](/records/architecture/shared-mutable-state), [Boundary Leakage](/records/architecture/boundary-leakage)", "term": "Violated by" }, { "description": "dependency cycles, unstable module graph", "term": "Detected by" }, { "description": "modularity score, graph density, instability", "term": "Measured by" }, { "description": "[Split Module](/records/lexicon/split-module), [Define Module Boundaries](/records/lexicon/define-module-boundaries), [Invert Dependency](/records/lexicon/invert-dependency)", "term": "Refactored by" }, { "description": "module rules, package ownership, [fitness functions](/records/architecture/fitness-functions)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooApplication {\n parse(raw: string) { return JSON.parse(raw) as Foo; }\n save(foo: Foo) { return fooDb.insert(foo); }\n publish(foo: Foo) { return fooBus.emit(foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const fooParser = { parse: (raw: string) => decodeFoo(raw) };\nexport const fooRepository = { save: (foo: Foo) => fooDb.insert(foo) };\nexport const fooPublisher = { publish: (foo: Foo) => fooBus.emit(foo) };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "module rules, package ownership, fitness functions", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[High Cohesion](/records/architecture/high-cohesion), [Low Coupling](/records/architecture/low-coupling), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Separation of Concerns](/records/architecture/separation-of-concerns), [Composability](/records/architecture/composability), [Replaceability](/records/architecture/replaceability), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Depends on" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-modularity", "title": "Modularity" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, component, system", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that parts share compatible interfaces and carry no hidden side effects, so they can be combined into larger parts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Low Coupling](/records/architecture/low-coupling)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Reusability](/records/architecture/reusability)", "term": "Reinforces" }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Enables" }, { "description": "[Performance Overhead](/records/lexicon/performance-overhead)", "term": "In tension with" }, { "description": "[Monolithic Procedures](/records/lexicon/monolithic-procedures)", "term": "Conflicts with" }, { "description": "[Modularity](/records/architecture/modularity), [Reusability](/records/architecture/reusability), [Decorator Pattern](/records/architecture/decorator-pattern), [Pipeline Architecture](/records/architecture/pipeline-architecture), [Component-Based Architecture](/records/architecture/component-based-architecture), [Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" }, { "description": "[Composability / Performance Overhead](/records/tension/composability-performance-overhead)", "term": "Tensions" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code): Composability lets parts combine through compatible interfaces, while DRY keeps one source for each piece of logic.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect), [Implementation-Specific Contracts](/records/lexicon/implementation-specific-contracts)", "term": "Violated by" }, { "description": "non-chainable APIs, incompatible contracts", "term": "Detected by" }, { "description": "composition count, interface compatibility", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Extract Module](/records/lexicon/extract-module), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Refactored by" }, { "description": "contract tests, type checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(raw: string) {\n const foo = JSON.parse(raw) as Foo;\n const normalized = { ...foo, name: foo.name.trim() };\n return fooDb.insert(normalized);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const parseFoo = (raw: string): Foo => decodeFoo(raw);\nconst normalizeFoo = (foo: Foo): Foo => ({ ...foo, name: foo.name.trim() });\nconst saveFoo = (foo: Foo) => fooDb.insert(foo);\nconst processFoo = flow(parseFoo, normalizeFoo, saveFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, type checks", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Low Coupling](/records/architecture/low-coupling), [Modularity](/records/architecture/modularity), [Reusability](/records/architecture/reusability), [Pipeline Architecture](/records/architecture/pipeline-architecture), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Depends on" }, { "description": "[Monolithic Procedures](/records/lexicon/monolithic-procedures)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-composability", "title": "Composability" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: class, component", "Aliases: Composite Reuse Principle", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that behavior is reused by holding and delegating to another object instead of extending its class.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Delegation](/records/lexicon/delegation), [Interface-Based Design](/records/architecture/interface-based-design)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern), [Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Enables" }, { "description": "[Simplicity for Trivial Reuse](/records/lexicon/simplicity-for-trivial-reuse)", "term": "In tension with" }, { "description": "[Deep Inheritance Hierarchy](/records/lexicon/deep-inheritance-hierarchy)", "term": "Conflicts with" }, { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Referenced by" }, { "description": "[Composition Over Inheritance / Simplicity for Trivial Reuse](/records/tension/composition-over-inheritance-simplicity-for-trivial-reuse)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Deep Inheritance Hierarchy](/records/lexicon/deep-inheritance-hierarchy), [Broken Inheritance](/records/lexicon/broken-inheritance)", "term": "Violated by" }, { "description": "inheritance depth, overridden behavior conflicts", "term": "Detected by" }, { "description": "inheritance depth, composition ratio", "term": "Measured by" }, { "description": "[Replace Inheritance with Delegation](/records/lexicon/replace-inheritance-with-delegation), [Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Refactored by" }, { "description": "inheritance depth limits, review rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class RetryingSqlFooStore extends SqlFooStore {\n async save(foo: Foo) {\n for (let attempt = 0; attempt < 3; attempt += 1) {\n try { return await super.save(foo); } catch (error) { if (attempt === 2) throw error; }\n }\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class RetryingFooStore implements FooStore {\n constructor(private readonly inner: FooStore, private readonly attempts: number) {}\n async save(foo: Foo) {\n for (let attempt = 0; attempt < this.attempts; attempt += 1) {\n try { return await this.inner.save(foo); } catch (error) { if (attempt === this.attempts - 1) throw error; }\n }\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "inheritance depth limits, review rules", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Delegation](/records/lexicon/delegation), [Interface-Based Design](/records/architecture/interface-based-design), [Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability), [Strategy Pattern](/records/architecture/strategy-pattern), [Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Depends on" }, { "description": "[Deep Inheritance Hierarchy](/records/lexicon/deep-inheritance-hierarchy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-composition-over-inheritance", "title": "Composition Over Inheritance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, module, component", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a function or module can serve a new caller without change, because it carries no context of its first one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Stable Contracts](/records/lexicon/stable-contracts)", "term": "Requires" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Composability](/records/architecture/composability)", "term": "Reinforces" }, { "description": "[Shared Libraries](/records/lexicon/shared-libraries), [Product Lines](/records/lexicon/product-lines)", "term": "Enables" }, { "description": "[YAGNI](/records/lexicon/yagni), [Over-Generalization](/records/lexicon/over-generalization)", "term": "In tension with" }, { "description": "[Context-Specific Coupling](/records/lexicon/context-specific-coupling)", "term": "Conflicts with" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Composability](/records/architecture/composability)", "term": "Referenced by" }, { "description": "[Reusability / YAGNI](/records/tension/reusability-yagni), [Reusability / Over-Generalization](/records/tension/over-generalization-reusability)", "term": "Tensions" }, { "description": "[Over-Generalization](/records/lexicon/over-generalization): Reusability serves new callers unchanged, while over-generalization is the clarity lost by making code serve every case.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Context-Specific Coupling](/records/lexicon/context-specific-coupling)", "term": "Violated by" }, { "description": "environment-specific logic in reusable code", "term": "Detected by" }, { "description": "reuse count, dependency portability", "term": "Measured by" }, { "description": "[Introduce Parameter Object](/records/lexicon/introduce-parameter-object), [Extract Module](/records/lexicon/extract-module), [Pass Context Explicitly](/records/lexicon/pass-context-explicitly)", "term": "Refactored by" }, { "description": "API review, dependency rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveAdminFoo(foo: Foo) { return adminFooDb.insert(foo); }\nfunction savePublicFoo(foo: Foo) { return publicFooDb.insert(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function saveFoo(store: FooStore, foo: Foo) { return store.save(foo); }\nconst saveAdminFoo = (foo: Foo) => saveFoo(adminFooStore, foo);\nconst savePublicFoo = (foo: Foo) => saveFoo(publicFooStore, foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API review, dependency rules", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Stable Contracts](/records/lexicon/stable-contracts), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Composability](/records/architecture/composability), [Shared Libraries](/records/lexicon/shared-libraries), [Product Lines](/records/lexicon/product-lines)", "term": "Depends on" }, { "description": "[Context-Specific Coupling](/records/lexicon/context-specific-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-reusability", "title": "Reusability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: component, service, infrastructure", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component can be swapped for another implementation of its interface without editing its callers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Low Coupling](/records/architecture/low-coupling)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Reinforces" }, { "description": "[Vendor Swap](/records/lexicon/vendor-swap), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Enables" }, { "description": "[Deep Optimization](/records/lexicon/deep-optimization)", "term": "In tension with" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Conflicts with" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Stable Interfaces](/records/architecture/stable-interfaces), [Portability](/records/architecture/portability), [Protocol Independence](/records/architecture/protocol-independence), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Separation of Concerns](/records/architecture/separation-of-concerns), [High Cohesion](/records/architecture/high-cohesion), [Low Coupling](/records/architecture/low-coupling), [Information Hiding](/records/architecture/information-hiding), [Abstraction](/records/architecture/abstraction), [Modularity](/records/architecture/modularity), [Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Interchangeability](/records/architecture/interchangeability), [Adapter Pattern](/records/architecture/adapter-pattern), [Dependency Injection](/records/architecture/dependency-injection), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Referenced by" }, { "description": "[Replaceability / Deep Optimization](/records/tension/deep-optimization-replaceability)", "term": "Tensions" }, { "description": "[High Cohesion](/records/architecture/high-cohesion): Replaceability is swapping an implementation, while high cohesion is members sharing one purpose.", "term": "Distinct from" }, { "description": "[Interchangeability](/records/architecture/interchangeability): Replaceability is substituting one implementation when the code changes, while interchangeability is selecting among several live implementations at runtime.", "term": "Distinct from" }, { "description": "[Portability](/records/architecture/portability): Replaceability swaps one component, while portability moves the whole software to another platform.", "term": "Distinct from" }, { "description": "[Reusability](/records/architecture/reusability): Replaceability puts a new implementation behind the same callers, while reusability serves a new caller with the same implementation.", "term": "Distinct from" }, { "description": "[Testability](/records/architecture/testability): Replaceability swaps an implementation in production, while testability supplies dependencies in a test.", "term": "Distinct from" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces): Replaceability swaps what sits behind an interface, while stable interfaces keep the interface itself unchanged across releases.", "term": "Distinct from" }, { "description": "[Maintainability](/records/lexicon/maintainability): Replaceability makes one kind of change cheap, while maintainability is the ease of every kind of correction and extension.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage)", "term": "Violated by" }, { "description": "infrastructure imports in core layers", "term": "Detected by" }, { "description": "adapter coverage, boundary purity", "term": "Measured by" }, { "description": "[Introduce Port](/records/lexicon/introduce-port), [Extract Adapter](/records/lexicon/extract-adapter), [Invert Dependency](/records/lexicon/invert-dependency)", "term": "Refactored by" }, { "description": "import restrictions, adapter tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n private readonly store = new SqlFooStore();\n save(foo: Foo) { return this.store.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {\n constructor(private readonly store: FooStore) {}\n save(foo: Foo) { return this.store.save(foo); }\n}\ntest(\"saves without a database\", async () => {\n const store = new MemoryFooStore();\n await new FooService(store).save(foo);\n expect(store.find(foo.id)).toEqual(foo);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "import restrictions, adapter tests", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Low Coupling](/records/architecture/low-coupling), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Vendor Swap](/records/lexicon/vendor-swap), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Depends on" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-replaceability", "title": "Replaceability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: component, plugin, service", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which several implementations conform to one contract closely enough to be selected at runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Contract Compatibility](/records/lexicon/contract-compatibility), [Contract Compatibility](/records/lexicon/contract-compatibility)", "term": "Requires" }, { "description": "[Replaceability](/records/architecture/replaceability), [Polymorphism](/records/architecture/polymorphism)", "term": "Reinforces" }, { "description": "[Strategy Swap](/records/lexicon/strategy-swap), [Strategy Swap](/records/lexicon/strategy-swap)", "term": "Enables" }, { "description": "[Specialized Optimization](/records/lexicon/specialized-optimization)", "term": "In tension with" }, { "description": "[Implementation-Specific Contracts](/records/lexicon/implementation-specific-contracts)", "term": "Conflicts with" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Referenced by" }, { "description": "[Interchangeability / Specialized Optimization](/records/tension/interchangeability-specialized-optimization)", "term": "Tensions" }, { "description": "[Specialized Optimization](/records/lexicon/specialized-optimization): Interchangeability lets implementations be swapped, while specialized optimization is the tuning for one implementation that it gives up.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implementation-Specific Contracts](/records/lexicon/implementation-specific-contracts)", "term": "Violated by" }, { "description": "contract test failure, incompatible schema", "term": "Detected by" }, { "description": "conformance score, compatibility tests", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Extract Adapter](/records/lexicon/extract-adapter), [Contract Testing](/records/lexicon/contract-testing)", "term": "Refactored by" }, { "description": "contract tests, [schema validation](/records/architecture/schema-validation)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function loadFoo(kind: \"sql\" | \"memory\", id: FooId) {\n if (kind === \"sql\") return sqlFooStore.find(id);\n return memoryFooStore.get(id);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooStore { find(id: FooId): Promise; }\nfunction loadFoo(store: FooStore, id: FooId) { return store.find(id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, schema validation", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Contract Compatibility](/records/lexicon/contract-compatibility), [Contract Compatibility](/records/lexicon/contract-compatibility), [Replaceability](/records/architecture/replaceability), [Polymorphism](/records/architecture/polymorphism), [Strategy Swap](/records/lexicon/strategy-swap), [Strategy Swap](/records/lexicon/strategy-swap)", "term": "Depends on" }, { "description": "[Implementation-Specific Contracts](/records/lexicon/implementation-specific-contracts)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-interchangeability", "title": "Interchangeability" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: module, service, deployment", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a module can be tested and deployed without the modules around it being present or released.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Low Coupling](/records/architecture/low-coupling), [Explicit Boundaries](/records/architecture/explicit-boundaries)", "term": "Requires" }, { "description": "[Autonomy](/records/architecture/autonomy), [Portability](/records/architecture/portability)", "term": "Reinforces" }, { "description": "[Independent Testing](/records/lexicon/independent-testing), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Enables" }, { "description": "[Coordination Cost](/records/lexicon/coordination-cost)", "term": "In tension with" }, { "description": "[Shared Runtime Dependency](/records/lexicon/shared-runtime-dependency)", "term": "Conflicts with" }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" }, { "description": "[Independence / Coordination Cost](/records/tension/coordination-cost-independence)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Database](/records/lexicon/shared-database), [Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Violated by" }, { "description": "shared mutable resources, deployment coupling", "term": "Detected by" }, { "description": "independent deployability, dependency count", "term": "Measured by" }, { "description": "[Split Bounded Context](/records/lexicon/split-bounded-context), [Domain Events](/records/architecture/domain-events), [Introduce Port](/records/lexicon/introduce-port)", "term": "Refactored by" }, { "description": "deployment rules, service ownership", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooModule {\n create(foo: Foo) {\n barModule.refresh(foo.id);\n bazModule.rebuild(foo.id);\n return fooDb.insert(foo);\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooModule {\n constructor(private readonly store: FooStore, private readonly events: EventSink) {}\n async create(foo: Foo) {\n await this.store.save(foo);\n this.events.emit({ type: \"FooCreated\", fooId: foo.id });\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment rules, service ownership", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Autonomy](/records/architecture/autonomy), [Portability](/records/architecture/portability), [Independent Testing](/records/lexicon/independent-testing), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Depends on" }, { "description": "[Shared Runtime Dependency](/records/lexicon/shared-runtime-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-independence", "title": "Independence" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/architecture-category/core-modular-design)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, team, bounded context", "Aliases: Service Autonomy", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a service or team owns its data and decisions, so it alone writes its data and others reach or change it only through its published API or events.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Independence](/records/architecture/independence), [Own Data](/records/lexicon/own-data), [Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Requires" }, { "description": "[Decentralization](/records/architecture/decentralization), [Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Microservices](/records/architecture/microservices), [Bounded Context Ownership](/records/lexicon/bounded-context-ownership), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Enables" }, { "description": "[Governance](/records/architecture/governance), [Standardization](/records/architecture/standardization), [Global Consistency](/records/lexicon/global-consistency)", "term": "In tension with" }, { "description": "[Centralized Runtime Control](/records/lexicon/centralized-runtime-control), [Shared Database](/records/lexicon/shared-database), [Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency)", "term": "Conflicts with" }, { "description": "[Bounded Context](/records/architecture/bounded-context), [Service Contract](/records/architecture/service-contract), [Decentralization](/records/architecture/decentralization), [Choreography](/records/architecture/choreography), [Independence](/records/architecture/independence), [Microservices](/records/architecture/microservices), [Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" }, { "description": "[Autonomy / Governance](/records/tension/autonomy-governance), [Autonomy / Standardization](/records/tension/autonomy-standardization), [Autonomy / Global Consistency](/records/tension/autonomy-global-consistency)", "term": "Tensions" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts): Autonomy is ownership of data and decisions, while explicit contracts are the declared boundaries others use to reach them.", "term": "Distinct from" }, { "description": "[Governance](/records/architecture/governance): Autonomy leaves decisions with their owner, while governance holds decisions to shared policy.", "term": "Distinct from" }, { "description": "[Standardization](/records/architecture/standardization): Autonomy lets each owner choose, while standardization fixes one choice everywhere.", "term": "Distinct from" }, { "description": "[Decentralization](/records/architecture/decentralization): Autonomy is one unit owning its data and decisions, while decentralization is the system-wide placement of control with those units.", "term": "Distinct from" }, { "description": "[Independence](/records/architecture/independence): Autonomy is ownership, while independence is being tested and deployed without the neighboring modules.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Database](/records/lexicon/shared-database), [Distributed Monolith](/records/architecture/distributed-monolith)", "term": "Violated by" }, { "description": "external writes to owned data, cross-team coupling", "term": "Detected by" }, { "description": "ownership clarity, deployment independence", "term": "Measured by" }, { "description": "[Own Data per Service](/records/lexicon/own-data-per-service), [Split Bounded Context](/records/lexicon/split-bounded-context), [Domain Events](/records/architecture/domain-events)", "term": "Refactored by" }, { "description": "ownership boundaries, API policies", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function createFoo(foo: Foo) {\n const bar = await barService.get(foo.barId);\n await bazService.validate(foo, bar);\n return fooStore.save(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function createFoo(foo: Foo) {\n await fooStore.save(foo);\n await outbox.append({ type: \"FooCreated\", fooId: foo.id, barId: foo.barId });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "ownership boundaries, API policies", "term": "Checked by" }, { "description": "Every class, module and package boundary in the codebase", "term": "Population" }, { "description": "A verdict stands until the module's contents, exports or imports change", "term": "Freshness" }, { "description": "The dependency, visibility or clone rule fails the build on the change that breaks the property", "term": "Refusal" }, { "description": "Cohesion, coupling, duplication and export metrics read from source and the import graph", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared module boundary, which every import and export conforms to", "term": "Authoritative side" }, { "description": "[Independence](/records/architecture/independence), [Own Data](/records/lexicon/own-data), [Explicit Contracts](/records/architecture/explicit-contracts), [Decentralization](/records/architecture/decentralization), [Resilience](/records/architecture/resilience), [Microservices](/records/architecture/microservices), [Bounded Context Ownership](/records/lexicon/bounded-context-ownership), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Depends on" }, { "description": "[Centralized Runtime Control](/records/lexicon/centralized-runtime-control), [Shared Database](/records/lexicon/shared-database), [Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-autonomy", "title": "Autonomy" } ], "title": "Core Modular Design" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_interface_segregation[\"Interface Segregation Principle (ISP)\"]\n n_dependency_inversion[\"Dependency Inversion Principle (DIP)\"]\n n_open_closed[\"Open/Closed Principle (OCP)\"]\n n_liskov_substitution[\"Liskov Substitution Principle (LSP)\"]\n n_polymorphism[\"Polymorphism\"]\n n_liskov_substitution --> n_polymorphism\n n_polymorphism --> n_open_closed" } ], "icon": "bi-collection", "id": "architecture-category-solid-object-oriented-design", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [SOLID / Object-Oriented Design](/records/architecture-category/solid-object-oriented-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: interface, service, module", "Aliases: ISP, Interface Segregation Principle", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a client depends on an interface holding only the methods it uses.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Role-Specific Interfaces](/records/lexicon/role-specific-interfaces)", "term": "Requires" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Consumer-Specific Contracts](/records/lexicon/consumer-specific-contracts)", "term": "Enables" }, { "description": "[Interface Proliferation](/records/lexicon/interface-proliferation)", "term": "In tension with" }, { "description": "[Fat Interface](/records/lexicon/fat-interface), [Repository Dump](/records/architecture/repository-dump)", "term": "Conflicts with" }, { "description": "[Interface Segregation Principle (ISP) / Interface Proliferation](/records/tension/interface-proliferation-interface-segregation-principle-isp)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fat Interface](/records/lexicon/fat-interface)", "term": "Violated by" }, { "description": "unused interface method implementations", "term": "Detected by" }, { "description": "interface method usage ratio", "term": "Measured by" }, { "description": "[Split Interface](/records/lexicon/split-interface), [Extract Role Interface](/records/lexicon/extract-role-interface)", "term": "Refactored by" }, { "description": "interface usage analysis, lint rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "interface FooWorker {\n load(id: FooId): Foo;\n save(foo: Foo): void;\n delete(id: FooId): void;\n export(): string;\n}\nclass FooReader implements FooWorker {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooReader { load(id: FooId): Foo; }\ninterface FooWriter { save(foo: Foo): void; }\ninterface FooRemover { delete(id: FooId): void; }\nclass CachedFooReader implements FooReader {\n load(id: FooId) { return fooCache.get(id)!; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "interface usage analysis, lint rules", "term": "Checked by" }, { "description": "Every interface, class hierarchy and dependency edge in the object model", "term": "Population" }, { "description": "A verdict stands until an interface, an override or a dependency changes", "term": "Freshness" }, { "description": "The dependency rule or the contract test fails a change that breaks substitution, segregation or dependency direction", "term": "Refusal" }, { "description": "Interface usage, override contracts and dependency direction, read from source and contract tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The interface contract, which every implementation and override conforms to", "term": "Authoritative side" }, { "description": "[Role-Specific Interfaces](/records/lexicon/role-specific-interfaces), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Low Coupling](/records/architecture/low-coupling), [Consumer-Specific Contracts](/records/lexicon/consumer-specific-contracts)", "term": "Depends on" }, { "description": "[Fat Interface](/records/lexicon/fat-interface), [Repository Dump](/records/architecture/repository-dump)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-interface-segregation", "title": "Interface Segregation Principle (ISP)" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [SOLID / Object-Oriented Design](/records/architecture-category/solid-object-oriented-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: module, component, layer", "Aliases: DIP, Dependency Inversion Principle", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that high-level policy and low-level detail both depend on an abstraction owned by the policy.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Reinforces" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Enables" }, { "description": "[Runtime Indirection](/records/lexicon/runtime-indirection)", "term": "In tension with" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Conflicts with" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design), [Testability](/records/architecture/testability), [Abstraction](/records/architecture/abstraction), [Replaceability](/records/architecture/replaceability), [Inversion of Control (IoC)](/records/architecture/inversion-of-control), [Dependency Injection](/records/architecture/dependency-injection), [Service Locator Pattern](/records/architecture/service-locator-pattern), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" }, { "description": "[Dependency Inversion Principle (DIP) / Runtime Indirection](/records/tension/dependency-inversion-principle-dip-runtime-indirection)", "term": "Tensions" }, { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control): Dependency inversion fixes which side owns the abstraction, while inversion of control moves object creation and control flow to a framework or composition root.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Violated by" }, { "description": "dependency direction violations", "term": "Detected by" }, { "description": "inward dependency ratio", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface), [Introduce Port](/records/lexicon/introduce-port), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "dependency graph rules, architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n private readonly store = new SqlFooStore();\n save(foo: Foo) { return this.store.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooStore { save(foo: Foo): Promise; }\nclass FooService {\n constructor(private readonly store: FooStore) {}\n save(foo: Foo) { return this.store.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency graph rules, architecture tests", "term": "Checked by" }, { "description": "Every interface, class hierarchy and dependency edge in the object model", "term": "Population" }, { "description": "A verdict stands until an interface, an override or a dependency changes", "term": "Freshness" }, { "description": "The dependency rule or the contract test fails a change that breaks substitution, segregation or dependency direction", "term": "Refusal" }, { "description": "Interface usage, override contracts and dependency direction, read from source and contract tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The interface contract, which every implementation and override conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Stable Interfaces](/records/architecture/stable-interfaces), [Low Coupling](/records/architecture/low-coupling), [Clean Architecture](/records/architecture/clean-architecture), [Dependency Injection](/records/architecture/dependency-injection), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Depends on" }, { "description": "[Concrete Coupling](/records/architecture/concrete-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dependency-inversion", "title": "Dependency Inversion Principle (DIP)" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [SOLID / Object-Oriented Design](/records/architecture-category/solid-object-oriented-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: class, module, component", "Aliases: OCP, Open-Closed Principle", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a module gains new behavior by adding code at an extension point, leaving its existing code unchanged.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Extension Points](/records/architecture/extension-points)", "term": "Requires" }, { "description": "[Plugin Architecture](/records/architecture/plugin-architecture), [Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Reinforces" }, { "description": "[Feature Extension without Modification](/records/lexicon/feature-extension-without-modification)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Switch-Based Extension](/records/lexicon/switch-based-extension)", "term": "Conflicts with" }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Polymorphism](/records/architecture/polymorphism), [Strategy Pattern](/records/architecture/strategy-pattern), [Command Pattern](/records/architecture/command-pattern), [State Pattern](/records/architecture/state-pattern), [Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern), [Visitor Pattern](/records/architecture/visitor-pattern), [Factory Pattern](/records/architecture/factory-pattern), [Factory Method Pattern](/records/architecture/factory-method-pattern), [Decorator Pattern](/records/architecture/decorator-pattern), [Composite Pattern](/records/architecture/composite-pattern), [Plugin Architecture](/records/architecture/plugin-architecture), [Extension Points](/records/architecture/extension-points)", "term": "Referenced by" }, { "description": "[Extensibility Core](/records/algorithms/extensibility-core)", "term": "Contracts" }, { "description": "[Open/Closed Principle (OCP) / Simplicity](/records/tension/open-closed-principle-ocp-simplicity)", "term": "Tensions" }, { "description": "[Composability](/records/architecture/composability): The open/closed principle adds behavior without editing existing code, while composability combines parts through compatible interfaces.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Switch-Based Extension](/records/lexicon/switch-based-extension)", "term": "Violated by" }, { "description": "growing conditionals, repeated edits to central classes", "term": "Detected by" }, { "description": "modification frequency of core modules", "term": "Measured by" }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern), [Extension Points](/records/architecture/extension-points), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Refactored by" }, { "description": "extension policies, change analysis", "term": "Enforced by" }, { "description": "open-closed", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function priceFoo(kind: string, value: number) {\n if (kind === \"foo\") return value;\n if (kind === \"bar\") return value * 2;\n throw new Error(\"unknown kind\");\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooPricing { price(value: number): number; }\nconst registry = new Map();\nexport function registerPricing(kind: string, pricing: FooPricing) { registry.set(kind, pricing); }\nexport function priceFoo(kind: string, value: number) {\n const pricing = registry.get(kind);\n if (!pricing) throw new Error(`unknown kind ${kind}`);\n return pricing.price(value);\n}\nregisterPricing(\"bar\", { price: value => value * 2 });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "extension policies, change analysis", "term": "Checked by" }, { "description": "Every interface, class hierarchy and dependency edge in the object model", "term": "Population" }, { "description": "A verdict stands until an interface, an override or a dependency changes", "term": "Freshness" }, { "description": "The dependency rule or the contract test fails a change that breaks substitution, segregation or dependency direction", "term": "Refusal" }, { "description": "Interface usage, override contracts and dependency direction, read from source and contract tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The interface contract, which every implementation and override conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Extension Points](/records/architecture/extension-points), [Plugin Architecture](/records/architecture/plugin-architecture), [Strategy Pattern](/records/architecture/strategy-pattern), [Feature Extension without Modification](/records/lexicon/feature-extension-without-modification)", "term": "Depends on" }, { "description": "[Switch-Based Extension](/records/lexicon/switch-based-extension)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-open-closed", "title": "Open/Closed Principle (OCP)" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [SOLID / Object-Oriented Design](/records/architecture-category/solid-object-oriented-design)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: class, interface, type hierarchy", "Aliases: LSP, Liskov Substitution Principle, Behavioral Subtyping", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a subtype can replace its base type anywhere, because it keeps the base type's preconditions, postconditions and invariants.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Contract Preservation](/records/lexicon/contract-preservation), [Preconditions](/records/architecture/preconditions), [Postconditions](/records/architecture/postconditions), [Invariant](/records/architecture/invariant)", "term": "Requires" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Type Safety](/records/architecture/type-safety)", "term": "Reinforces" }, { "description": "[Safe Substitution](/records/lexicon/safe-substitution), [Substitutability](/records/lexicon/substitutability)", "term": "Enables" }, { "description": "[Narrow Specialized Behavior](/records/lexicon/narrow-specialized-behavior)", "term": "In tension with" }, { "description": "[Broken Inheritance](/records/lexicon/broken-inheritance), [Broken Inheritance](/records/lexicon/broken-inheritance)", "term": "Conflicts with" }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Referenced by" }, { "description": "[Liskov Substitution Principle (LSP) / Narrow Specialized Behavior](/records/tension/liskov-substitution-principle-lsp-narrow-specialized-behavior)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Broken Inheritance](/records/lexicon/broken-inheritance)", "term": "Violated by" }, { "description": "overridden method contract divergence", "term": "Detected by" }, { "description": "contract test pass rate across subtypes", "term": "Measured by" }, { "description": "[Replace Inheritance with Delegation](/records/lexicon/replace-inheritance-with-delegation), [Extract Interface](/records/lexicon/extract-interface), [Split Hierarchy](/records/lexicon/split-hierarchy)", "term": "Refactored by" }, { "description": "contract tests, type tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooStore {\n save(foo: Foo): Promise { return persist(foo); }\n}\nclass ReadOnlyFooStore extends FooStore {\n save(): Promise { throw new Error(\"not supported\"); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooStore {\n save(foo: Foo): Promise { return persist(foo); }\n}\nclass AuditedFooStore extends FooStore {\n async save(foo: Foo): Promise {\n const receipt = await super.save(foo);\n audit.record(receipt);\n return receipt;\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "contract tests, type tests", "term": "Checked by" }, { "description": "Every interface, class hierarchy and dependency edge in the object model", "term": "Population" }, { "description": "A verdict stands until an interface, an override or a dependency changes", "term": "Freshness" }, { "description": "The dependency rule or the contract test fails a change that breaks substitution, segregation or dependency direction", "term": "Refusal" }, { "description": "Interface usage, override contracts and dependency direction, read from source and contract tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The interface contract, which every implementation and override conforms to", "term": "Authoritative side" }, { "description": "[Contract Preservation](/records/lexicon/contract-preservation), [Preconditions](/records/architecture/preconditions), [Postconditions](/records/architecture/postconditions), [Invariant](/records/architecture/invariant), [Polymorphism](/records/architecture/polymorphism), [Type Safety](/records/architecture/type-safety), [Safe Substitution](/records/lexicon/safe-substitution), [Substitutability](/records/lexicon/substitutability)", "term": "Depends on" }, { "description": "[Broken Inheritance](/records/lexicon/broken-inheritance), [Broken Inheritance](/records/lexicon/broken-inheritance)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-liskov-substitution", "title": "Liskov Substitution Principle (LSP)" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [SOLID / Object-Oriented Design](/records/architecture-category/solid-object-oriented-design)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: class, interface, runtime", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets one interface have several implementations, with the implementation chosen by the object that receives the call.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Substitutability](/records/lexicon/substitutability)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Reinforces" }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Interchangeability](/records/architecture/interchangeability)", "term": "Enables" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "In tension with" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Conflicts with" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Abstraction](/records/architecture/abstraction), [Interchangeability](/records/architecture/interchangeability), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Strategy Pattern](/records/architecture/strategy-pattern), [State Pattern](/records/architecture/state-pattern), [Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" }, { "description": "[Polymorphism / Traceability](/records/tension/polymorphism-traceability)", "term": "Tensions" }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch): Polymorphism is one interface with several implementations, while dynamic dispatch is the runtime selection of which one runs, from the receiver or a keyed table.", "term": "Distinct from" }, { "description": "[Type Safety](/records/architecture/type-safety): Polymorphism varies the implementation behind a type, while type safety rejects operations on the wrong type.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Violated by" }, { "description": "conditional type checks, duplicated branching", "term": "Detected by" }, { "description": "polymorphic dispatch ratio", "term": "Measured by" }, { "description": "[Replace Conditional with Polymorphism](/records/lexicon/replace-conditional-with-polymorphism)", "term": "Refactored by" }, { "description": "[code review](/records/architecture/code-review), static analysis rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renderFoo(kind: string, foo: Foo) {\n if (kind === \"text\") return foo.name;\n if (kind === \"json\") return JSON.stringify(foo);\n throw new Error(\"unknown renderer\");\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooRenderer { render(foo: Foo): string; }\nclass TextFooRenderer implements FooRenderer { render(foo: Foo) { return foo.name; } }\nclass JsonFooRenderer implements FooRenderer { render(foo: Foo) { return JSON.stringify(foo); } }\nfunction renderFoo(renderer: FooRenderer, foo: Foo) { return renderer.render(foo); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "code review, static analysis rules", "term": "Checked by" }, { "description": "Every interface, class hierarchy and dependency edge in the object model", "term": "Population" }, { "description": "A verdict stands until an interface, an override or a dependency changes", "term": "Freshness" }, { "description": "The dependency rule or the contract test fails a change that breaks substitution, segregation or dependency direction", "term": "Refusal" }, { "description": "Interface usage, override contracts and dependency direction, read from source and contract tests", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The interface contract, which every implementation and override conforms to", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Substitutability](/records/lexicon/substitutability), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Strategy Pattern](/records/architecture/strategy-pattern), [Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Interchangeability](/records/architecture/interchangeability)", "term": "Depends on" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-polymorphism", "title": "Polymorphism" } ], "title": "SOLID / Object-Oriented Design" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_event_driven_architecture[\"Event-Driven Architecture\"]\n n_publish_subscribe_pattern[\"Publish/Subscribe Pattern\"]\n n_message_queue[\"Message Queue\"]\n n_message_broker[\"Message Broker\"]\n n_event_bus[\"Event Bus\"]\n n_event_stream[\"Event Stream\"]\n n_event_sourcing[\"Event Sourcing\"]\n n_command_query_responsibility_segregation[\"Command Query Responsibility Segregation (CQRS)\"]\n n_domain_events[\"Domain Events\"]\n n_integration_events[\"Integration Events\"]\n n_asynchronous_communication[\"Asynchronous Communication\"]\n n_eventual_consistency[\"Eventual Consistency\"]\n n_saga_pattern[\"Saga Pattern\"]\n n_outbox_pattern[\"Outbox Pattern\"]\n n_compensating_transaction[\"Compensating Transaction\"]\n n_append_only_log[\"Append-Only Log\"]\n n_dead_letter_queue[\"Dead-Letter Queue\"]\n n_idempotent_consumer[\"Idempotent Consumer\"]\n n_competing_consumers[\"Competing Consumers\"]\n n_event_driven_architecture --> n_asynchronous_communication\n n_event_driven_architecture --> n_event_sourcing\n n_event_driven_architecture --> n_command_query_responsibility_segregation\n n_event_driven_architecture --> n_saga_pattern\n n_message_broker --> n_message_queue\n n_message_broker --> n_publish_subscribe_pattern\n n_event_bus --> n_publish_subscribe_pattern\n n_event_bus --> n_event_driven_architecture\n n_event_sourcing --> n_append_only_log\n n_event_sourcing --> n_domain_events\n n_command_query_responsibility_segregation --> n_event_sourcing\n n_command_query_responsibility_segregation -.-> n_eventual_consistency\n n_domain_events --> n_event_driven_architecture\n n_asynchronous_communication --> n_event_driven_architecture\n n_saga_pattern --> n_compensating_transaction\n n_saga_pattern --> n_eventual_consistency\n n_compensating_transaction --> n_saga_pattern\n n_append_only_log --> n_event_sourcing\n n_dead_letter_queue --> n_message_queue\n n_idempotent_consumer --> n_eventual_consistency\n n_competing_consumers --> n_message_queue" } ], "icon": "bi-collection", "id": "architecture-category-event-messaging-asynchronous-architecture", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, integration, system", "Aliases: EDA", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of connecting services through published events, with each consumer reacting independently of the producer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Events](/records/lexicon/events), [Message Contract](/records/lexicon/message-contract), [Idempotency](/records/architecture/idempotency)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Asynchronous Communication](/records/architecture/asynchronous-communication)", "term": "Reinforces" }, { "description": "[Event Sourcing](/records/architecture/event-sourcing), [Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Enables" }, { "description": "[Debuggability](/records/lexicon/debuggability), [Strong Consistency](/records/lexicon/strong-consistency)", "term": "In tension with" }, { "description": "[Hidden Temporal Coupling](/records/lexicon/hidden-temporal-coupling)", "term": "Conflicts with" }, { "description": "[Choreography](/records/architecture/choreography), [Event Bus](/records/architecture/event-bus), [Domain Events](/records/architecture/domain-events), [Asynchronous Communication](/records/architecture/asynchronous-communication), [Observer Pattern](/records/architecture/observer-pattern), [Idempotency](/records/architecture/idempotency)", "term": "Referenced by" }, { "description": "[Event-Driven Architecture / Debuggability](/records/tension/debuggability-event-driven-architecture), [Event-Driven Architecture / Strong Consistency](/records/tension/event-driven-architecture-strong-consistency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Non-Idempotent Operation](/records/lexicon/non-idempotent-operation), [Ad-Hoc Payloads](/records/lexicon/ad-hoc-payloads)", "term": "Violated by" }, { "description": "missing correlation IDs, direct synchronous chains", "term": "Detected by" }, { "description": "event contract coverage, [retry safety](/records/lexicon/retry-safety)", "term": "Measured by" }, { "description": "[Domain Events](/records/architecture/domain-events), [Outbox Pattern](/records/architecture/outbox-pattern), [Consumer-Driven Contract Tests](/records/lexicon/consumer-driven-contract-tests)", "term": "Refactored by" }, { "description": "[schema registry](/records/lexicon/schema-registry), idempotency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function createFoo(foo: Foo) {\n await fooStore.save(foo);\n await barService.refresh(foo.id);\n await bazService.notify(foo.id);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function createFoo(foo: Foo) {\n await fooStore.save(foo);\n await events.publish({ type: \"FooCreated\", fooId: foo.id });\n}\nevents.on(\"FooCreated\", updateBarProjection);\nevents.on(\"FooCreated\", notifyBaz);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema registry, idempotency tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Events](/records/lexicon/events), [Message Contract](/records/lexicon/message-contract), [Idempotency](/records/architecture/idempotency), [Low Coupling](/records/architecture/low-coupling), [Asynchronous Communication](/records/architecture/asynchronous-communication), [Event Sourcing](/records/architecture/event-sourcing), [Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Depends on" }, { "description": "[Hidden Temporal Coupling](/records/lexicon/hidden-temporal-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-event-driven-architecture", "title": "Event-Driven Architecture" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: integration, eventing", "Aliases: Pub/Sub", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which publishers send messages to a topic and every subscriber to that topic receives them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Publisher](/records/lexicon/publisher), [Subscriber](/records/lexicon/subscriber), [Broker/Event Bus](/records/lexicon/broker-event-bus)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Fan-Out Notification](/records/lexicon/fan-out-notification)", "term": "Enables" }, { "description": "[Delivery Ordering](/records/lexicon/delivery-ordering)", "term": "In tension with" }, { "description": "[Direct Point-to-Point Calls](/records/lexicon/direct-point-to-point-calls)", "term": "Conflicts with" }, { "description": "[Message Broker](/records/architecture/message-broker), [Event Bus](/records/architecture/event-bus)", "term": "Referenced by" }, { "description": "[Publish/Subscribe Pattern / Delivery Ordering](/records/tension/delivery-ordering-publish-subscribe-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Point-to-Point Coupling](/records/lexicon/point-to-point-coupling)", "term": "Violated by" }, { "description": "direct calls to subscriber list", "term": "Detected by" }, { "description": "publisher-subscriber coupling", "term": "Measured by" }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Refactored by" }, { "description": "messaging contracts", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) {\n fooStore.save(foo);\n auditFoo(foo);\n indexFoo(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "publisher.publish(\"foo.saved\", { fooId: foo.id });\nsubscriber.on(\"foo.saved\", auditFoo);\nsubscriber.on(\"foo.saved\", indexFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "messaging contracts", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Publisher](/records/lexicon/publisher), [Subscriber](/records/lexicon/subscriber), [Broker/Event Bus](/records/lexicon/broker-event-bus), [Low Coupling](/records/architecture/low-coupling), [Fan-Out Notification](/records/lexicon/fan-out-notification)", "term": "Depends on" }, { "description": "[Direct Point-to-Point Calls](/records/lexicon/direct-point-to-point-calls)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-publish-subscribe-pattern", "title": "Publish/Subscribe Pattern" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: integration, async processing", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that holds messages durably until a consumer takes and acknowledges each one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Contract](/records/lexicon/message-contract), [Consumer](/records/lexicon/consumer)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Backpressure](/records/architecture/backpressure)", "term": "Reinforces" }, { "description": "[Asynchronous Processing](/records/lexicon/asynchronous-processing)", "term": "Enables" }, { "description": "[Latency](/records/architecture/latency)", "term": "In tension with" }, { "description": "[In-Memory Direct Invocation](/records/lexicon/in-memory-direct-invocation)", "term": "Conflicts with" }, { "description": "[Message Broker](/records/architecture/message-broker), [Dead-Letter Queue](/records/architecture/dead-letter-queue), [Competing Consumers](/records/architecture/competing-consumers)", "term": "Referenced by" }, { "description": "[Message Queue / Latency](/records/tension/latency-message-queue)", "term": "Tensions" }, { "description": "[Consumer](/records/lexicon/consumer): A message queue holds messages until they are acknowledged, while the consumer is the component that takes and processes them.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Violated by" }, { "description": "synchronous blocking chains for async work", "term": "Detected by" }, { "description": "queue depth, retry/dead-letter rates", "term": "Measured by" }, { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Refactored by" }, { "description": "infrastructure policy, load tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "for (const foo of foos) await processFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for (const foo of foos) await fooQueue.enqueue({ type: \"ProcessFoo\", foo });\nfooWorker.consume(fooQueue, message => processFoo(message.foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure policy, load tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Contract](/records/lexicon/message-contract), [Consumer](/records/lexicon/consumer), [Resilience](/records/architecture/resilience), [Backpressure](/records/architecture/backpressure), [Asynchronous Processing](/records/lexicon/asynchronous-processing)", "term": "Depends on" }, { "description": "[In-Memory Direct Invocation](/records/lexicon/in-memory-direct-invocation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-message-queue", "title": "Message Queue" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: integration, messaging", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about topics, queues and routing rules, held by an intermediary service that delivers messages between producers and consumers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue), [Routing](/records/lexicon/routing)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Work Distribution](/records/lexicon/work-distribution)", "term": "Enables" }, { "description": "[Operational Dependency](/records/lexicon/operational-dependency)", "term": "In tension with" }, { "description": "[Point-to-Point Coupling](/records/lexicon/point-to-point-coupling)", "term": "Conflicts with" }, { "description": "[Message Broker / Operational Dependency](/records/tension/message-broker-operational-dependency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct Point-to-Point Calls](/records/lexicon/direct-point-to-point-calls)", "term": "Violated by" }, { "description": "direct service calls in async workflows", "term": "Detected by" }, { "description": "broker usage coverage", "term": "Measured by" }, { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Refactored by" }, { "description": "architecture policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooService.sendToBar(barMessage);\nawait fooService.sendToBaz(bazMessage);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await broker.publish(\"foo.created\", fooMessage, { durable: true });\nbroker.subscribe(\"foo.created\", { group: \"bar-consumer\", ack: \"manual\" }, handleBar);\nbroker.subscribe(\"foo.created\", { group: \"baz-consumer\", ack: \"manual\" }, handleBaz);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture policy", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Queue](/records/architecture/message-queue), [Routing](/records/lexicon/routing), [Low Coupling](/records/architecture/low-coupling), [Scalability](/records/architecture/scalability), [Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Work Distribution](/records/lexicon/work-distribution)", "term": "Depends on" }, { "description": "[Point-to-Point Coupling](/records/lexicon/point-to-point-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-message-broker", "title": "Message Broker" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, integration", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that dispatches each emitted event to the handlers registered for its type.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Event Contract](/records/lexicon/event-contract), [Subscriber Model](/records/lexicon/subscriber-model)", "term": "Requires" }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Reinforces" }, { "description": "[Decoupled Event Distribution](/records/lexicon/decoupled-event-distribution)", "term": "Enables" }, { "description": "[Event Storm / Traceability](/records/lexicon/event-storm-traceability)", "term": "In tension with" }, { "description": "[Direct Event Handler Calls](/records/lexicon/direct-event-handler-calls)", "term": "Conflicts with" }, { "description": "[Event Bus / Event Storm / Traceability](/records/tension/event-bus-event-storm-traceability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "undocumented subscribers", "term": "Detected by" }, { "description": "event dependency visibility", "term": "Measured by" }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Refactored by" }, { "description": "handler registry validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooEditor.onSave = foo => fooView.refresh(foo);\nfooEditor.onDelete = id => fooView.remove(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "eventBus.emit({ type: \"FooSaved\", foo });\neventBus.emit({ type: \"FooDeleted\", fooId: id });\neventBus.on(\"FooSaved\", event => fooView.refresh(event.foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "handler registry validation", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Event Contract](/records/lexicon/event-contract), [Subscriber Model](/records/lexicon/subscriber-model), [Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Decoupled Event Distribution](/records/lexicon/decoupled-event-distribution)", "term": "Depends on" }, { "description": "[Direct Event Handler Calls](/records/lexicon/direct-event-handler-calls)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-event-bus", "title": "Event Bus" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: stream processing, integration", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that keeps events in an ordered, replayable log that consumers read from their own offset.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ordered Log](/records/lexicon/ordered-log), [Event Schema](/records/lexicon/event-schema)", "term": "Requires" }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Reinforces" }, { "description": "[Replay](/records/lexicon/replay), [Continuous Processing](/records/lexicon/continuous-processing)", "term": "Enables" }, { "description": "[Storage Volume](/records/lexicon/storage-volume)", "term": "In tension with" }, { "description": "[Mutable State Only](/records/lexicon/mutable-state-only)", "term": "Conflicts with" }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Referenced by" }, { "description": "[Event Stream / Storage Volume](/records/tension/event-stream-storage-volume)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Non-Replayable Processing](/records/lexicon/non-replayable-processing)", "term": "Violated by" }, { "description": "missing offsets, missing event schema", "term": "Detected by" }, { "description": "replay success, lag", "term": "Measured by" }, { "description": "[Offset Tracking](/records/lexicon/offset-tracking)", "term": "Refactored by" }, { "description": "stream contract tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const latest = await fooApi.getCurrentState(fooId);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const stream = fooEvents.stream(fooId);\nfor await (const event of stream) fooProjection.apply(event);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "stream contract tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Ordered Log](/records/lexicon/ordered-log), [Event Schema](/records/lexicon/event-schema), [Streaming Architecture](/records/architecture/streaming-architecture), [Replay](/records/lexicon/replay), [Continuous Processing](/records/lexicon/continuous-processing)", "term": "Depends on" }, { "description": "[Mutable State Only](/records/lexicon/mutable-state-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-event-stream", "title": "Event Stream" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, persistence", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that stores state as the sequence of events that produced it and rebuilds current state by replaying them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Append-Only Log](/records/architecture/append-only-log), [Domain Events](/records/architecture/domain-events)", "term": "Requires" }, { "description": "[Auditability](/records/architecture/auditability), [Temporal Modeling](/records/lexicon/temporal-modeling)", "term": "Reinforces" }, { "description": "[Replay](/records/lexicon/replay), [Replay](/records/lexicon/replay)", "term": "Enables" }, { "description": "[Query Complexity](/records/lexicon/query-complexity)", "term": "In tension with" }, { "description": "[CRUD-Only State Persistence](/records/lexicon/crud-only-state-persistence)", "term": "Conflicts with" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation), [Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" }, { "description": "[Event Sourcing / Query Complexity](/records/tension/event-sourcing-query-complexity)", "term": "Tensions" }, { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation): Event sourcing stores state as its events, while CQRS separates the command model from the query model whatever the storage.", "term": "Distinct from" }, { "description": "[Append-Only Log](/records/architecture/append-only-log): Event sourcing rebuilds state by replay, while an append-only log is the storage it replays from.", "term": "Distinct from" }, { "description": "[Domain Events](/records/architecture/domain-events): Event sourcing makes events the source of state, while domain events can be published with state stored some other way.", "term": "Distinct from" }, { "description": "[Saga Pattern](/records/architecture/saga-pattern): Event sourcing is how state is stored, while a saga is how a distributed transaction is coordinated.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[CRUD-Only State Persistence](/records/lexicon/crud-only-state-persistence)", "term": "Violated by" }, { "description": "state changes lacking events", "term": "Detected by" }, { "description": "event/state consistency", "term": "Measured by" }, { "description": "[Query Projection](/records/lexicon/query-projection)", "term": "Refactored by" }, { "description": "event append rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type FooRow = { id: FooId; name: string; status: string };\nawait fooTable.update(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooEvent = FooCreated | FooRenamed | FooClosed;\nawait fooEventStore.append(foo.id, foo.uncommittedEvents());\nconst foo = fooEventStore.read(fooId).reduce(applyFooEvent, emptyFoo());", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "event append rules", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Append-Only Log](/records/architecture/append-only-log), [Domain Events](/records/architecture/domain-events), [Auditability](/records/architecture/auditability), [Temporal Modeling](/records/lexicon/temporal-modeling), [Replay](/records/lexicon/replay), [Replay](/records/lexicon/replay)", "term": "Depends on" }, { "description": "[CRUD-Only State Persistence](/records/lexicon/crud-only-state-persistence)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-event-sourcing", "title": "Event Sourcing" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, data access", "Aliases: CQRS", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that separates the model that handles commands from the model that answers queries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Command/Query Separation](/records/lexicon/command-query-separation)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Event Sourcing](/records/architecture/event-sourcing)", "term": "Reinforces" }, { "description": "[Read/Write Model Optimization](/records/lexicon/read-write-model-optimization)", "term": "Enables" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "In tension with" }, { "description": "[Unified CRUD Model](/records/lexicon/unified-crud-model)", "term": "Conflicts with" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Referenced by" }, { "description": "[Command Query Responsibility Segregation (CQRS) / Eventual Consistency](/records/tension/command-query-responsibility-segregation-cqrs-eventual-consistency)", "term": "Tensions" }, { "description": "[Saga Pattern](/records/architecture/saga-pattern): CQRS splits the write model from the read model, while a saga sequences local transactions with compensations.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unified CRUD Model](/records/lexicon/unified-crud-model)", "term": "Violated by" }, { "description": "command/query side-effect violations", "term": "Detected by" }, { "description": "read/write separation compliance", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "handler conventions, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooRepository {\n save(foo: Foo) {}\n search(query: string): Foo[] { return complexJoin(query); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooCommandStore { save(foo: Foo) { return fooDb.write(foo); } }\nclass FooQueryStore { search(query: string) { return fooReadModel.search(query); } }\ncommandBus.execute(new SaveFoo(foo));\nqueryBus.execute(new SearchFoos(query));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "handler conventions, tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Command/Query Separation](/records/lexicon/command-query-separation), [Scalability](/records/architecture/scalability), [Event Sourcing](/records/architecture/event-sourcing), [Read/Write Model Optimization](/records/lexicon/read-write-model-optimization)", "term": "Depends on" }, { "description": "[Unified CRUD Model](/records/lexicon/unified-crud-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-command-query-responsibility-segregation", "title": "Command Query Responsibility Segregation (CQRS)" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: domain, bounded context", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that records each significant change in the domain as an event named in the domain's language.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Domain Model](/records/architecture/domain-model), [Event Semantics](/records/lexicon/event-semantics)", "term": "Requires" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Reinforces" }, { "description": "[Decoupled Domain Reactions](/records/lexicon/decoupled-domain-reactions)", "term": "Enables" }, { "description": "[Event Granularity](/records/lexicon/event-granularity)", "term": "In tension with" }, { "description": "[Infrastructure Events in Domain](/records/lexicon/infrastructure-events-in-domain)", "term": "Conflicts with" }, { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Referenced by" }, { "description": "[Domain Events / Event Granularity](/records/tension/domain-events-event-granularity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Infrastructure Events in Domain](/records/lexicon/infrastructure-events-in-domain)", "term": "Violated by" }, { "description": "CRUD-named domain events", "term": "Detected by" }, { "description": "semantic event quality", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "domain review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class Foo {\n rename(name: string) { this.name = name; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class Foo {\n #events: FooDomainEvent[] = [];\n rename(name: string) {\n this.name = name;\n this.#events.push({ type: \"FooRenamed\", fooId: this.id, name });\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "domain review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Domain Model](/records/architecture/domain-model), [Event Semantics](/records/lexicon/event-semantics), [Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Decoupled Domain Reactions](/records/lexicon/decoupled-domain-reactions)", "term": "Depends on" }, { "description": "[Infrastructure Events in Domain](/records/lexicon/infrastructure-events-in-domain)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-domain-events", "title": "Domain Events" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: service boundary, messaging", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that publishes a versioned public event, mapped from an internal domain event, for consumers outside the service.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Contract](/records/lexicon/message-contract), [Versioning](/records/architecture/versioning)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Cross-Service Communication](/records/lexicon/cross-service-communication)", "term": "Enables" }, { "description": "[Duplication with Domain Events](/records/lexicon/duplication-with-domain-events)", "term": "In tension with" }, { "description": "[Internal Domain Event Leakage](/records/lexicon/internal-domain-event-leakage)", "term": "Conflicts with" }, { "description": "[Integration Events / Duplication with Domain Events](/records/tension/duplication-with-domain-events-integration-events)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Internal Domain Event Leakage](/records/lexicon/internal-domain-event-leakage)", "term": "Violated by" }, { "description": "internal event schema published externally", "term": "Detected by" }, { "description": "boundary event contract coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "event schema review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "barService.consume(fooDomainEvent);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const integrationEvent: FooCreatedV1 = {\n type: \"com.example.foo-created.v1\",\n fooId: event.fooId,\n occurredAt: clock.now().toISOString(),\n};\nintegrationBus.publish(integrationEvent);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "event schema review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Contract](/records/lexicon/message-contract), [Versioning](/records/architecture/versioning), [Interoperability](/records/architecture/interoperability), [Cross-Service Communication](/records/lexicon/cross-service-communication)", "term": "Depends on" }, { "description": "[Internal Domain Event Leakage](/records/lexicon/internal-domain-event-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-integration-events", "title": "Integration Events" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, system", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that work the caller does not need at once is sent as a message, so the caller does not wait on it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Contract](/records/lexicon/message-contract), [Retry Safety](/records/lexicon/retry-safety)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Enables" }, { "description": "[Immediate Consistency](/records/lexicon/immediate-consistency)", "term": "In tension with" }, { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Conflicts with" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Referenced by" }, { "description": "[Asynchronous Communication / Immediate Consistency](/records/tension/asynchronous-communication-immediate-consistency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Violated by" }, { "description": "long blocking chains", "term": "Detected by" }, { "description": "sync dependency depth", "term": "Measured by" }, { "description": "[Message Queue](/records/architecture/message-queue), [Query Projection](/records/lexicon/query-projection)", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const bar = await barService.createFromFoo(foo);\nconst baz = await bazService.createFromBar(bar);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await outbox.append({ type: \"FooCreated\", fooId: foo.id });\nreturn { accepted: true, fooId: foo.id };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Contract](/records/lexicon/message-contract), [Retry Safety](/records/lexicon/retry-safety), [Resilience](/records/architecture/resilience), [Low Coupling](/records/architecture/low-coupling), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Depends on" }, { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap), [Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-asynchronous-communication", "title": "Asynchronous Communication" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: distributed system, data", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a consistency guarantee in which replicas and projections converge once updates stop arriving.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Idempotency](/records/architecture/idempotency), [Retry Pattern](/records/architecture/retry-pattern), [Reconciliation](/records/lexicon/reconciliation)", "term": "Requires" }, { "description": "[Availability](/records/lexicon/availability), [Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Distributed Autonomy](/records/lexicon/distributed-autonomy)", "term": "Enables" }, { "description": "[User Expectations](/records/lexicon/user-expectations), [Strong Immediate Consistency](/records/lexicon/strong-immediate-consistency)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[CRDTs](/records/architecture/crdts), [CAP Theorem](/records/architecture/cap-theorem), [Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation), [Saga Pattern](/records/architecture/saga-pattern), [Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" }, { "description": "[Eventual Consistency / User Expectations](/records/tension/eventual-consistency-user-expectations), [Eventual Consistency / Strong Immediate Consistency](/records/tension/eventual-consistency-strong-immediate-consistency)", "term": "Tensions" }, { "description": "[Causal Consistency](/records/architecture/causal-consistency): Eventual consistency promises only that replicas converge, while causal consistency also promises that no effect is read before its cause.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Global ACID Transaction](/records/lexicon/global-acid-transaction)", "term": "Violated by" }, { "description": "synchronous compensation hacks", "term": "Detected by" }, { "description": "convergence time, inconsistency window", "term": "Measured by" }, { "description": "[Query Projection](/records/lexicon/query-projection), [Reconciliation Job](/records/lexicon/reconciliation-job), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Refactored by" }, { "description": "consistency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooStore.save(foo);\nawait fooSearch.update(foo);\nawait fooAnalytics.update(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await fooStore.save(foo);\nfooEvents.emit({ type: \"FooSaved\", foo });\nconst view = await fooSearchView.find(foo.id);\nconst converged = view.version >= foo.version;\nreturn { foo: view, converged };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "consistency tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Idempotency](/records/architecture/idempotency), [Retry Pattern](/records/architecture/retry-pattern), [Reconciliation](/records/lexicon/reconciliation), [Availability](/records/lexicon/availability), [Scalability](/records/architecture/scalability), [Distributed Autonomy](/records/lexicon/distributed-autonomy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-eventual-consistency", "title": "Eventual Consistency" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service workflow, distributed system", "Aliases: Saga", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that runs a cross-service transaction as a sequence of local steps, each paired with a compensating step.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Compensating Transaction](/records/architecture/compensating-transaction), [Idempotency](/records/architecture/idempotency)", "term": "Requires" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Reinforces" }, { "description": "[Long-Running Transactions](/records/lexicon/long-running-transactions)", "term": "Enables" }, { "description": "[Workflow Complexity](/records/lexicon/workflow-complexity)", "term": "In tension with" }, { "description": "[Global ACID Transaction](/records/lexicon/global-acid-transaction)", "term": "Conflicts with" }, { "description": "[Orchestration](/records/architecture/orchestration), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Referenced by" }, { "description": "[Saga Pattern / Workflow Complexity](/records/tension/saga-pattern-workflow-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Global ACID Transaction](/records/lexicon/global-acid-transaction), [Hidden Distributed Transaction](/records/lexicon/hidden-distributed-transaction)", "term": "Violated by" }, { "description": "distributed transaction attempts", "term": "Detected by" }, { "description": "compensation coverage", "term": "Measured by" }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Refactored by" }, { "description": "workflow tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const tx = coordinator.begin();\nawait fooService.prepare(tx, foo);\nawait barService.prepare(tx, bar);\nawait bazService.prepare(tx, baz);\nawait coordinator.commit(tx);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await saga([\n { action: () => fooService.create(foo), compensate: id => fooService.cancel(id) },\n { action: () => barService.create(bar), compensate: id => barService.cancel(id) },\n { action: () => bazService.create(baz), compensate: id => bazService.cancel(id) },\n]).run();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "workflow tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction), [Idempotency](/records/architecture/idempotency), [Eventual Consistency](/records/architecture/eventual-consistency), [Long-Running Transactions](/records/lexicon/long-running-transactions)", "term": "Depends on" }, { "description": "[Global ACID Transaction](/records/lexicon/global-acid-transaction)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-saga-pattern", "title": "Saga Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: persistence, messaging", "Aliases: Transactional Outbox", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that writes an outgoing message in the same local transaction as the state change, and a relay publishes it afterwards.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Local Transaction](/records/lexicon/local-transaction), [Message Relay](/records/lexicon/message-relay)", "term": "Requires" }, { "description": "[Event Reliability](/records/lexicon/event-reliability)", "term": "Reinforces" }, { "description": "[Atomic State Change + Message Publish](/records/lexicon/atomic-state-change-message-publish)", "term": "Enables" }, { "description": "[Relay Complexity](/records/lexicon/relay-complexity)", "term": "In tension with" }, { "description": "[Dual Write](/records/architecture/dual-write)", "term": "Conflicts with" }, { "description": "[Outbox Pattern / Relay Complexity](/records/tension/outbox-pattern-relay-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Dual Write](/records/architecture/dual-write)", "term": "Violated by" }, { "description": "dual-write patterns", "term": "Detected by" }, { "description": "lost-message rate, outbox coverage", "term": "Measured by" }, { "description": "[Message Relay](/records/lexicon/message-relay)", "term": "Refactored by" }, { "description": "persistence rules, integration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooStore.save(foo);\nawait eventBus.publish({ type: \"FooSaved\", fooId: foo.id });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await database.transaction(async tx => {\n await tx.foos.save(foo);\n await tx.outbox.insert({ id: eventId(), type: \"FooSaved\", fooId: foo.id });\n});\nawait outboxRelay.publishPending();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "persistence rules, integration tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Local Transaction](/records/lexicon/local-transaction), [Message Relay](/records/lexicon/message-relay), [Event Reliability](/records/lexicon/event-reliability), [Atomic State Change + Message Publish](/records/lexicon/atomic-state-change-message-publish)", "term": "Depends on" }, { "description": "[Dual Write](/records/architecture/dual-write)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-outbox-pattern", "title": "Outbox Pattern" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: workflow, distributed transaction", "Aliases: Compensating Action", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that undoes the business effect of a completed step when a later step of the workflow fails.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Reversible/Compensable Step](/records/lexicon/reversible-compensable-step)", "term": "Requires" }, { "description": "[Saga Pattern](/records/architecture/saga-pattern), [Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Failure Recovery](/records/lexicon/failure-recovery)", "term": "Enables" }, { "description": "[Business Complexity](/records/lexicon/business-complexity)", "term": "In tension with" }, { "description": "[Irreversible Side Effects](/records/lexicon/irreversible-side-effects)", "term": "Conflicts with" }, { "description": "[Saga Pattern](/records/architecture/saga-pattern)", "term": "Referenced by" }, { "description": "[Compensating Transaction / Business Complexity](/records/tension/business-complexity-compensating-transaction)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Irreversible Side Effects](/records/lexicon/irreversible-side-effects)", "term": "Violated by" }, { "description": "saga steps without compensation", "term": "Detected by" }, { "description": "compensation coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "workflow tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooService.create(foo);\nawait barService.create(bar);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooId = await fooService.create(foo);\ntry {\n await barService.create(bar);\n} catch (error) {\n await fooService.compensateCreate(fooId);\n throw error;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "workflow tests", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Reversible/Compensable Step](/records/lexicon/reversible-compensable-step), [Saga Pattern](/records/architecture/saga-pattern), [Resilience](/records/architecture/resilience), [Failure Recovery](/records/lexicon/failure-recovery)", "term": "Depends on" }, { "description": "[Irreversible Side Effects](/records/lexicon/irreversible-side-effects)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-compensating-transaction", "title": "Compensating Transaction" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: event store, audit, stream", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that records history as immutable entries added at the end of the log.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Immutable Events](/records/lexicon/immutable-events)", "term": "Requires" }, { "description": "[Auditability](/records/architecture/auditability), [Event Sourcing](/records/architecture/event-sourcing)", "term": "Reinforces" }, { "description": "[Replay](/records/lexicon/replay), [Temporal Queries](/records/lexicon/temporal-queries)", "term": "Enables" }, { "description": "[Storage Growth](/records/lexicon/storage-growth)", "term": "In tension with" }, { "description": "[In-Place Mutation](/records/lexicon/in-place-mutation)", "term": "Conflicts with" }, { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Referenced by" }, { "description": "[Append-Only Log / Storage Growth](/records/tension/append-only-log-storage-growth)", "term": "Tensions" }, { "description": "[Domain Events](/records/architecture/domain-events): An append-only log is the storage shape that never rewrites an entry, while domain events are what gets recorded, named in the domain's language.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[In-Place Mutation](/records/lexicon/in-place-mutation)", "term": "Violated by" }, { "description": "mutable event rows", "term": "Detected by" }, { "description": "append-only compliance", "term": "Measured by" }, { "description": "[Snapshot Compaction](/records/lexicon/snapshot-compaction)", "term": "Refactored by" }, { "description": "database constraints", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooState.set(foo.id, foo);\nfooState.delete(foo.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooLogEntry = FooCreated | FooUpdated | FooRemoved;\nfooLog.append({ seq: nextSeq(), type: \"FooRemoved\", fooId: foo.id });\nconst state = projectFooLog(fooLog.read());", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "database constraints", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Immutable Events](/records/lexicon/immutable-events), [Auditability](/records/architecture/auditability), [Event Sourcing](/records/architecture/event-sourcing), [Replay](/records/lexicon/replay), [Temporal Queries](/records/lexicon/temporal-queries)", "term": "Depends on" }, { "description": "[In-Place Mutation](/records/lexicon/in-place-mutation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-append-only-log", "title": "Append-Only Log" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production systems", "Scope: service, messaging, resilience", "Aliases: DLQ", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that moves a message which keeps failing into a separate queue, where it can be inspected and reprocessed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Requires" }, { "description": "[Fault Isolation](/records/lexicon/fault-isolation), [Observability](/records/architecture/observability)", "term": "Reinforces" }, { "description": "[Poison-Message Quarantine](/records/lexicon/poison-message-quarantine), [Reprocessing After Fix](/records/lexicon/reprocessing-after-fix)", "term": "Enables" }, { "description": "[Operational Overhead](/records/lexicon/operational-overhead)", "term": "In tension with" }, { "description": "[Infinite Redelivery Loop](/records/lexicon/infinite-redelivery-loop)", "term": "Conflicts with" }, { "description": "[Dead-Letter Queue / Operational Overhead](/records/tension/dead-letter-queue-operational-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Infinite Redelivery Loop](/records/lexicon/infinite-redelivery-loop)", "term": "Violated by" }, { "description": "retry storms on a single poison message", "term": "Detected by" }, { "description": "redelivery count per failed message", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "messaging design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "worker.consume(fooQueue, async message => {\n await processFoo(message);\n});", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "worker.consume(fooQueue, async message => {\n try {\n await processFoo(message);\n } catch (error) {\n if (message.attempts >= 5) return fooDeadLetterQueue.send(message, error);\n throw error;\n }\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "messaging design review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Queue](/records/architecture/message-queue), [Fault Isolation](/records/lexicon/fault-isolation), [Observability](/records/architecture/observability), [Poison-Message Quarantine](/records/lexicon/poison-message-quarantine), [Reprocessing After Fix](/records/lexicon/reprocessing-after-fix)", "term": "Depends on" }, { "description": "[Infinite Redelivery Loop](/records/lexicon/infinite-redelivery-loop)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dead-letter-queue", "title": "Dead-Letter Queue" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: service, messaging, correctness", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which a consumer records each message it has processed, so a redelivered message has no second effect.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Deduplication Key](/records/lexicon/deduplication-key)", "term": "Requires" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency), [At-Least-Once Delivery Safety](/records/lexicon/at-least-once-delivery-safety)", "term": "Reinforces" }, { "description": "[Safe Message Redelivery](/records/lexicon/safe-message-redelivery)", "term": "Enables" }, { "description": "[State Overhead](/records/lexicon/state-overhead)", "term": "In tension with" }, { "description": "[Duplicate Side Effects](/records/lexicon/duplicate-side-effects)", "term": "Conflicts with" }, { "description": "[Idempotent Consumer / State Overhead](/records/tension/idempotent-consumer-state-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Duplicate Side Effects](/records/lexicon/duplicate-side-effects)", "term": "Violated by" }, { "description": "duplicate effects under at-least-once delivery", "term": "Detected by" }, { "description": "duplicate-processing incident rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "messaging design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "worker.consume(fooQueue, message => chargeFoo(message.fooId, message.amount));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "worker.consume(fooQueue, async message => {\n if (await processedMessages.has(message.id)) return;\n await chargeFoo(message.fooId, message.amount);\n await processedMessages.add(message.id);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "messaging design review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Deduplication Key](/records/lexicon/deduplication-key), [Eventual Consistency](/records/architecture/eventual-consistency), [At-Least-Once Delivery Safety](/records/lexicon/at-least-once-delivery-safety), [Safe Message Redelivery](/records/lexicon/safe-message-redelivery)", "term": "Depends on" }, { "description": "[Duplicate Side Effects](/records/lexicon/duplicate-side-effects)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-idempotent-consumer", "title": "Idempotent Consumer" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Event / Messaging / Asynchronous Architecture](/records/architecture-category/event-messaging-asynchronous-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, messaging, scalability", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which several consumers read from one queue, and each message goes to only one of them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Requires" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing)", "term": "Reinforces" }, { "description": "[Parallel Message Processing](/records/lexicon/parallel-message-processing), [Consumer Elasticity](/records/lexicon/consumer-elasticity)", "term": "Enables" }, { "description": "[Ordering](/records/lexicon/ordering)", "term": "In tension with" }, { "description": "[Single Serial Consumer](/records/lexicon/single-serial-consumer)", "term": "Conflicts with" }, { "description": "[Competing Consumers / Ordering](/records/tension/competing-consumers-ordering)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Serial Consumer](/records/lexicon/single-serial-consumer)", "term": "Violated by" }, { "description": "queue depth rising with a single processor", "term": "Detected by" }, { "description": "consumer utilization vs backlog growth", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "messaging design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooWorker.consume(fooQueue, processFoo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for (let worker = 0; worker < WORKER_COUNT; worker += 1) {\n new FooWorker(worker).consume(fooQueue, processFoo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "messaging design review", "term": "Checked by" }, { "description": "Every event, message, topic and consumer that crosses an asynchronous boundary", "term": "Population" }, { "description": "A verdict stands until an event schema, a consumer or the delivery guarantee changes", "term": "Freshness" }, { "description": "The schema registry, idempotency test or workflow test fails the change that breaks delivery or contract", "term": "Refusal" }, { "description": "Published schemas, consumer registrations, and redelivery, lag and dead-letter counts from the broker", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The published schema and the delivery guarantee, which every producer and consumer conforms to", "term": "Authoritative side" }, { "description": "[Message Queue](/records/architecture/message-queue), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing), [Parallel Message Processing](/records/lexicon/parallel-message-processing), [Consumer Elasticity](/records/lexicon/consumer-elasticity)", "term": "Depends on" }, { "description": "[Single Serial Consumer](/records/lexicon/single-serial-consumer)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-competing-consumers", "title": "Competing Consumers" } ], "title": "Event / Messaging / Asynchronous Architecture" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_defensive_programming[\"Defensive Programming\"]\n n_fail_fast[\"Fail Fast\"]\n n_fail_safe[\"Fail Safe\"]\n n_fail_secure[\"Fail Secure\"]\n n_graceful_degradation[\"Graceful Degradation\"]\n n_fault_tolerance[\"Fault Tolerance\"]\n n_resilience[\"Resilience\"]\n n_robustness_principle[\"Robustness Principle\"]\n n_error_handling[\"Error Handling\"]\n n_error_boundaries[\"Error Boundaries\"]\n n_fallback_pattern[\"Fallback Pattern\"]\n n_retry_pattern[\"Retry Pattern\"]\n n_timeout_pattern[\"Timeout Pattern\"]\n n_circuit_breaker_pattern[\"Circuit Breaker Pattern\"]\n n_bulkhead_pattern[\"Bulkhead Pattern\"]\n n_backpressure[\"Backpressure\"]\n n_defensive_programming --> n_error_handling\n n_defensive_programming --> n_fail_fast\n n_fail_fast -.-> n_graceful_degradation\n n_fail_safe --> n_resilience\n n_graceful_degradation --> n_fault_tolerance\n n_fault_tolerance --> n_error_handling\n n_fault_tolerance --> n_resilience\n n_resilience --> n_fault_tolerance\n n_error_handling --> n_resilience\n n_error_boundaries --> n_resilience\n n_fallback_pattern --> n_graceful_degradation\n n_retry_pattern --> n_fault_tolerance\n n_circuit_breaker_pattern --> n_fault_tolerance\n n_circuit_breaker_pattern --> n_backpressure\n n_backpressure --> n_resilience" } ], "icon": "bi-collection", "id": "architecture-category-error-handling-resilience", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, module, boundary", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that code checks its inputs and assumptions before acting on them, and reports a violation as an explicit error.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Input Validation](/records/architecture/input-validation), [Error Handling](/records/architecture/error-handling)", "term": "Requires" }, { "description": "[Robustness](/records/lexicon/robustness), [Fail Fast](/records/architecture/fail-fast)", "term": "Reinforces" }, { "description": "[Safe Failure](/records/lexicon/safe-failure)", "term": "Enables" }, { "description": "[Verbosity](/records/lexicon/verbosity)", "term": "In tension with" }, { "description": "[Trusting Invalid Inputs](/records/lexicon/trusting-invalid-inputs)", "term": "Conflicts with" }, { "description": "[Defensive Programming / Verbosity](/records/tension/defensive-programming-verbosity)", "term": "Tensions" }, { "description": "[Error Handling](/records/architecture/error-handling): Defensive programming checks inputs and assumptions before acting, while error handling decides what happens to an error once raised.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Trusting Invalid Inputs](/records/lexicon/trusting-invalid-inputs)", "term": "Violated by" }, { "description": "null/empty/range unsafe access", "term": "Detected by" }, { "description": "guard coverage, runtime exception rate", "term": "Measured by" }, { "description": "[Precondition Check](/records/lexicon/precondition-check), [Input Validation](/records/architecture/input-validation)", "term": "Refactored by" }, { "description": "linting, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renameFoo(foo: Foo, name: string) {\n foo.name = name.trim();\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function renameFoo(foo: Foo | undefined, name: unknown) {\n if (!foo) throw new Error(\"Foo required\");\n if (typeof name !== \"string\" || name.trim().length === 0) throw new Error(\"valid name required\");\n return { ...foo, name: name.trim() };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "linting, tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Input Validation](/records/architecture/input-validation), [Error Handling](/records/architecture/error-handling), [Robustness](/records/lexicon/robustness), [Fail Fast](/records/architecture/fail-fast), [Safe Failure](/records/lexicon/safe-failure)", "term": "Depends on" }, { "description": "[Trusting Invalid Inputs](/records/lexicon/trusting-invalid-inputs)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-defensive-programming", "title": "Defensive Programming" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: input, startup, invariant boundary", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that invalid input or state stops the operation at the point it is detected, with an explicit error.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Preconditions](/records/architecture/preconditions), [Validation](/records/architecture/validation)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Observability](/records/architecture/observability)", "term": "Reinforces" }, { "description": "[Early Defect Detection](/records/lexicon/early-defect-detection)", "term": "Enables" }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "In tension with" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Silent Data Corruption](/records/architecture/silent-data-corruption)", "term": "Conflicts with" }, { "description": "[Preconditions](/records/architecture/preconditions), [Defensive Programming](/records/architecture/defensive-programming), [Schema Validation](/records/architecture/schema-validation), [Input Validation](/records/architecture/input-validation)", "term": "Referenced by" }, { "description": "[Correctness Core](/records/algorithms/correctness-core)", "term": "Contracts" }, { "description": "[Fail Fast / Graceful Degradation](/records/tension/fail-fast-graceful-degradation)", "term": "Tensions" }, { "description": "[Defensive Programming](/records/architecture/defensive-programming): Fail fast stops the operation where invalid state is found, while defensive programming is the checking that finds it.", "term": "Distinct from" }, { "description": "[Design by Contract](/records/architecture/design-by-contract): Fail fast is how a violation is handled, by stopping, while design by contract is where the conditions are stated.", "term": "Distinct from" }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation): Fail fast stops on invalid state, while graceful degradation keeps the rest running when an optional dependency fails.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exception Swallowing](/records/lexicon/exception-swallowing)", "term": "Violated by" }, { "description": "ignored exceptions, default fallbacks masking errors", "term": "Detected by" }, { "description": "late failure rate", "term": "Measured by" }, { "description": "[Precondition Check](/records/lexicon/precondition-check), [Fail Fast or Fall Back](/records/lexicon/fail-fast-or-fall-back)", "term": "Refactored by" }, { "description": "validation tests", "term": "Enforced by" }, { "description": "fail-fast", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "const fooUrl = process.env.FOO_URL ?? \"http://localhost:3000\";\nstartFooApp(fooUrl);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooUrl = process.env.FOO_URL;\nif (!fooUrl) throw new Error(\"FOO_URL is required\");\nstartFooApp(new URL(fooUrl));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "validation tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Preconditions](/records/architecture/preconditions), [Validation](/records/architecture/validation), [Correctness](/records/architecture/correctness), [Observability](/records/architecture/observability), [Early Defect Detection](/records/lexicon/early-defect-detection)", "term": "Depends on" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Silent Data Corruption](/records/architecture/silent-data-corruption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fail-fast", "title": "Fail Fast" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: runtime, operation, security", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a failing operation leaves the system in the state that causes the least harm.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Safe Defaults](/records/lexicon/safe-defaults)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Damage Limitation](/records/lexicon/damage-limitation)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability)", "term": "In tension with" }, { "description": "[Unsafe Default Continuation](/records/lexicon/unsafe-default-continuation)", "term": "Conflicts with" }, { "description": "[Fail Safe / Availability](/records/tension/availability-fail-safe)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unsafe Default Continuation](/records/lexicon/unsafe-default-continuation)", "term": "Violated by" }, { "description": "fallback to unsafe behavior", "term": "Detected by" }, { "description": "unsafe failure modes", "term": "Measured by" }, { "description": "[Fallback Pattern](/records/architecture/fallback-pattern), [Fail Fast or Fall Back](/records/lexicon/fail-fast-or-fall-back)", "term": "Refactored by" }, { "description": "failure-mode tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "try {\n await openFooGate();\n} catch {\n fooGate.unlock();\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "try {\n await openFooGate();\n} catch {\n fooGate.lock();\n throw new Error(\"Foo gate remains locked\");\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "failure-mode tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Safe Defaults](/records/lexicon/safe-defaults), [Resilience](/records/architecture/resilience), [Damage Limitation](/records/lexicon/damage-limitation)", "term": "Depends on" }, { "description": "[Unsafe Default Continuation](/records/lexicon/unsafe-default-continuation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fail-safe", "title": "Fail Safe" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: auth, access, infrastructure", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an authentication or policy failure denies access.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Requires" }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Reinforces" }, { "description": "[Deny-by-Default Behavior](/records/lexicon/deny-by-default-behavior)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability)", "term": "In tension with" }, { "description": "[Fail Open](/records/lexicon/fail-open)", "term": "Conflicts with" }, { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Referenced by" }, { "description": "[Fail Secure / Availability](/records/tension/availability-fail-secure)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fail Open](/records/lexicon/fail-open)", "term": "Violated by" }, { "description": "fail-open branches", "term": "Detected by" }, { "description": "fail-open count", "term": "Measured by" }, { "description": "[Default Deny](/records/lexicon/default-deny)", "term": "Refactored by" }, { "description": "security tests, policy checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function authorizeFoo(token?: string) {\n if (!token) return { role: \"admin\" };\n return decodeToken(token);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function authorizeFoo(token?: string): FooIdentity {\n if (!token) throw new UnauthorizedError();\n const identity = verifyToken(token);\n if (!identity) throw new UnauthorizedError();\n return identity;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security tests, policy checks", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Secure by Default](/records/architecture/secure-by-default), [Security by Design](/records/architecture/security-by-design), [Deny-by-Default Behavior](/records/lexicon/deny-by-default-behavior)", "term": "Depends on" }, { "description": "[Fail Open](/records/lexicon/fail-open)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fail-secure", "title": "Fail Secure" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: service, UX, system", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that the failure of an optional dependency removes only the feature it serves, and the rest of the system keeps working.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Fallback](/records/lexicon/fallback), [Feature Isolation](/records/lexicon/feature-isolation)", "term": "Requires" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Partial Availability](/records/lexicon/partial-availability)", "term": "Enables" }, { "description": "[Consistency / Feature Completeness](/records/lexicon/consistency-feature-completeness)", "term": "In tension with" }, { "description": "[All-Or-Nothing Failure](/records/lexicon/all-or-nothing-failure)", "term": "Conflicts with" }, { "description": "[Fail Fast](/records/architecture/fail-fast), [Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Referenced by" }, { "description": "[Graceful Degradation / Consistency / Feature Completeness](/records/tension/consistency-feature-completeness-graceful-degradation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[All-Or-Nothing Failure](/records/lexicon/all-or-nothing-failure)", "term": "Violated by" }, { "description": "critical path dependency on optional service", "term": "Detected by" }, { "description": "partial availability under failure", "term": "Measured by" }, { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Refactored by" }, { "description": "chaos tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function renderFooPage() {\n const foo = await fooService.get();\n const bar = await barRecommendations.get();\n return render(foo, bar);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function renderFooPage() {\n const foo = await fooService.get();\n const bar = await barRecommendations.get().catch(() => [] as Bar[]);\n return render(foo, bar);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "chaos tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Fallback](/records/lexicon/fallback), [Feature Isolation](/records/lexicon/feature-isolation), [Fault Tolerance](/records/architecture/fault-tolerance), [Partial Availability](/records/lexicon/partial-availability)", "term": "Depends on" }, { "description": "[All-Or-Nothing Failure](/records/lexicon/all-or-nothing-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-graceful-degradation", "title": "Graceful Degradation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, system, infrastructure", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system keeps operating correctly when some of its components fail.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Redundancy](/records/architecture/redundancy), [Error Handling](/records/architecture/error-handling)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Continued Operation Under Failure](/records/lexicon/continued-operation-under-failure)", "term": "Enables" }, { "description": "[Cost](/records/lexicon/cost)", "term": "In tension with" }, { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Conflicts with" }, { "description": "[Leader Election](/records/architecture/leader-election), [Consensus](/records/architecture/consensus), [Graceful Degradation](/records/architecture/graceful-degradation), [Resilience](/records/architecture/resilience), [Retry Pattern](/records/architecture/retry-pattern), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern), [Redundancy](/records/architecture/redundancy), [Chaos Engineering](/records/architecture/chaos-engineering), [RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" }, { "description": "[Fault Tolerance / Cost](/records/tension/cost-fault-tolerance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Violated by" }, { "description": "no retry/failover/fallback for critical path", "term": "Detected by" }, { "description": "failure recovery rate, [availability](/records/lexicon/availability)", "term": "Measured by" }, { "description": "[Bounded Retry](/records/lexicon/bounded-retry), [Failover](/records/architecture/failover), [Redundancy](/records/architecture/redundancy)", "term": "Refactored by" }, { "description": "resilience tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await fooReplicaA.read(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await firstSuccessful([\n () => fooReplicaA.read(id),\n () => fooReplicaB.read(id),\n () => fooReplicaC.read(id),\n]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "resilience tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Redundancy](/records/architecture/redundancy), [Error Handling](/records/architecture/error-handling), [Resilience](/records/architecture/resilience), [Continued Operation Under Failure](/records/lexicon/continued-operation-under-failure)", "term": "Depends on" }, { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fault-tolerance", "title": "Fault Tolerance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production systems", "Scope: service, system, infrastructure", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system contains failures, stays stable under stress and recovers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Observability](/records/architecture/observability)", "term": "Requires" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture), [Recovery](/records/lexicon/recovery)", "term": "Reinforces" }, { "description": "[Stability Under Stress](/records/lexicon/stability-under-stress)", "term": "Enables" }, { "description": "[Complexity](/records/lexicon/complexity)", "term": "In tension with" }, { "description": "[Brittle Architecture](/records/lexicon/brittle-architecture)", "term": "Conflicts with" }, { "description": "[Service Discovery](/records/architecture/service-discovery), [Decentralization](/records/architecture/decentralization), [Autonomy](/records/architecture/autonomy), [Message Queue](/records/architecture/message-queue), [Asynchronous Communication](/records/architecture/asynchronous-communication), [Compensating Transaction](/records/architecture/compensating-transaction), [Fail Safe](/records/architecture/fail-safe), [Fault Tolerance](/records/architecture/fault-tolerance), [Error Handling](/records/architecture/error-handling), [Error Boundaries](/records/architecture/error-boundaries), [Backpressure](/records/architecture/backpressure), [Observability](/records/architecture/observability), [Statelessness](/records/architecture/statelessness), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Rollback](/records/architecture/rollback)", "term": "Referenced by" }, { "description": "[Resilience / Complexity](/records/tension/complexity-resilience)", "term": "Tensions" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance): Resilience contains failures and recovers from them, while fault tolerance keeps operating correctly while components are failing.", "term": "Distinct from" }, { "description": "[Low Coupling](/records/architecture/low-coupling): Resilience is surviving failure, while low coupling is surviving change.", "term": "Distinct from" }, { "description": "[Observability](/records/architecture/observability): Resilience is containing and recovering from failure, while observability is seeing what the system does.", "term": "Distinct from" }, { "description": "[Complexity](/records/lexicon/complexity): Resilience is surviving failure, while complexity is the intricacy that its mechanisms add.", "term": "Distinct from" }, { "description": "[Debuggability](/records/lexicon/debuggability): Resilience is recovering without help, while debuggability is how easily the developer can locate a fault.", "term": "Distinct from" }, { "description": "[Stability](/records/lexicon/stability): Resilience includes recovery after failure, while stability is steady operation under load without collapse.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Failure Propagation](/records/lexicon/failure-propagation)", "term": "Violated by" }, { "description": "[failure propagation](/records/lexicon/failure-propagation), lack of isolation", "term": "Detected by" }, { "description": "MTTR, error budget, [availability](/records/lexicon/availability)", "term": "Measured by" }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern), [Bulkhead Pattern](/records/architecture/bulkhead-pattern), [Retry Pattern](/records/architecture/retry-pattern), [Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Refactored by" }, { "description": "[chaos testing](/records/reasoning/technique-chaos-testing), SLO gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function loadFoo(id: FooId) { return remoteFoo.get(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function loadFoo(id: FooId) {\n return circuitBreaker.execute(() => retry.withBackoff(() => remoteFoo.get(id), { attempts: 3 }));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "chaos testing, SLO gates", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Observability](/records/architecture/observability), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Recovery](/records/lexicon/recovery), [Stability Under Stress](/records/lexicon/stability-under-stress)", "term": "Depends on" }, { "description": "[Brittle Architecture](/records/lexicon/brittle-architecture)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-resilience", "title": "Resilience" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: protocol, API, input processing", "Aliases: Postel's Law", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a component is strict in what it sends and tolerant of harmless variation in what it receives.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Strict Output](/records/lexicon/strict-output), [Tolerant Input](/records/lexicon/tolerant-input)", "term": "Requires" }, { "description": "[Compatibility](/records/lexicon/compatibility)", "term": "Reinforces" }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Enables" }, { "description": "[Strict Validation](/records/lexicon/strict-validation)", "term": "In tension with" }, { "description": "[Fragile Parsing](/records/lexicon/fragile-parsing)", "term": "Conflicts with" }, { "description": "[Robustness Principle / Strict Validation](/records/tension/robustness-principle-strict-validation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fragile Parsing](/records/lexicon/fragile-parsing)", "term": "Violated by" }, { "description": "parser brittleness", "term": "Detected by" }, { "description": "compatibility failure rate", "term": "Measured by" }, { "description": "[Canonicalization](/records/architecture/canonicalization), [Invariant Check](/records/lexicon/invariant-check)", "term": "Refactored by" }, { "description": "compatibility test suite", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function readFoo(message: any) { return { id: message.id, name: message.name }; }\nfunction writeFoo(foo: Foo) { return { ...foo, debug: globalThis }; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function readFoo(message: unknown) {\n const value = FooEnvelopeSchema.parse(message);\n return { id: value.id, name: value.name };\n}\nfunction writeFoo(foo: Foo): FooEnvelopeV1 { return { version: 1, id: foo.id, name: foo.name }; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compatibility test suite", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Strict Output](/records/lexicon/strict-output), [Tolerant Input](/records/lexicon/tolerant-input), [Compatibility](/records/lexicon/compatibility), [Interoperability](/records/architecture/interoperability)", "term": "Depends on" }, { "description": "[Fragile Parsing](/records/lexicon/fragile-parsing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-robustness-principle", "title": "Robustness Principle" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, module, service", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every error is either handled with its context kept, or propagated as a typed error the caller must handle.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Error Model](/records/lexicon/error-model), [Observability](/records/architecture/observability)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Controlled Failure](/records/lexicon/controlled-failure)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Exception Swallowing](/records/lexicon/exception-swallowing), [Exception Control Flow](/records/architecture/exception-control-flow)", "term": "Conflicts with" }, { "description": "[Defensive Programming](/records/architecture/defensive-programming), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Referenced by" }, { "description": "[Error Handling / Simplicity](/records/tension/error-handling-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exception Swallowing](/records/lexicon/exception-swallowing), [Silent Failure](/records/lexicon/silent-failure)", "term": "Violated by" }, { "description": "empty catch blocks, unchecked result errors", "term": "Detected by" }, { "description": "unhandled error count", "term": "Measured by" }, { "description": "[Introduce Typed Result](/records/lexicon/introduce-typed-result), [Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Refactored by" }, { "description": "linting, [tests](/records/lexicon/tests)", "term": "Enforced by" }, { "description": "error-handling", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "async function loadFoo(id: FooId) {\n try { return await fooStore.find(id); } catch { return null; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type LoadFooResult =\n | { ok: true; value: Foo }\n | { ok: false; error: \"NOT_FOUND\" | \"STORE_UNAVAILABLE\" };\nasync function loadFoo(id: FooId): Promise {\n return fooStore.findResult(id);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "linting, tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Error Model](/records/lexicon/error-model), [Observability](/records/architecture/observability), [Resilience](/records/architecture/resilience), [Correctness](/records/architecture/correctness), [Controlled Failure](/records/lexicon/controlled-failure)", "term": "Depends on" }, { "description": "[Exception Swallowing](/records/lexicon/exception-swallowing), [Exception Control Flow](/records/architecture/exception-control-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-error-handling", "title": "Error Handling" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: component, UI, service boundary", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that catches failures at a component boundary, so a failing part renders or returns an error while the rest keeps running.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Failure Isolation](/records/lexicon/failure-isolation)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Localized Recovery](/records/lexicon/localized-recovery)", "term": "Enables" }, { "description": "[Hidden Errors](/records/lexicon/hidden-errors)", "term": "In tension with" }, { "description": "[Failure Propagation](/records/lexicon/failure-propagation)", "term": "Conflicts with" }, { "description": "[Error Boundaries / Hidden Errors](/records/tension/error-boundaries-hidden-errors)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Failure Propagation](/records/lexicon/failure-propagation)", "term": "Violated by" }, { "description": "uncaught exceptions crossing boundary", "term": "Detected by" }, { "description": "blast radius", "term": "Measured by" }, { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Refactored by" }, { "description": "failure tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renderApp() { return renderFooPanel(loadFoo()); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function FooBoundary({ render }: { render(): View }) {\n try { return render(); }\n catch (error) { return renderFooError(toFooError(error)); }\n}\nconst app = FooBoundary({ render: () => renderFooPanel(loadFoo()) });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "failure tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Failure Isolation](/records/lexicon/failure-isolation), [Resilience](/records/architecture/resilience), [Localized Recovery](/records/lexicon/localized-recovery)", "term": "Depends on" }, { "description": "[Failure Propagation](/records/lexicon/failure-propagation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-error-boundaries", "title": "Error Boundaries" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, dependency call", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that routes a failed call to an alternate provider or response declared in advance.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Alternate Behavior](/records/lexicon/alternate-behavior)", "term": "Requires" }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Reinforces" }, { "description": "[Partial Availability](/records/lexicon/partial-availability)", "term": "Enables" }, { "description": "[Stale/Reduced Results](/records/lexicon/stale-reduced-results)", "term": "In tension with" }, { "description": "[Single Behavior Path](/records/lexicon/single-behavior-path)", "term": "Conflicts with" }, { "description": "[Fallback Pattern / Stale/Reduced Results](/records/tension/fallback-pattern-stale-reduced-results)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Behavior Path](/records/lexicon/single-behavior-path)", "term": "Violated by" }, { "description": "hard dependency in optional path", "term": "Detected by" }, { "description": "fallback coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "failure injection tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await primaryFooStore.find(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await primaryFooStore.find(id).catch(() => replicaFooStore.find(id));\nif (!foo) throw new FooUnavailableError(id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "failure injection tests", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Alternate Behavior](/records/lexicon/alternate-behavior), [Graceful Degradation](/records/architecture/graceful-degradation), [Partial Availability](/records/lexicon/partial-availability)", "term": "Depends on" }, { "description": "[Single Behavior Path](/records/lexicon/single-behavior-path)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fallback-pattern", "title": "Fallback Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: network, IO, message handling", "Aliases: Retry", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that repeats an idempotent call after a transient failure, a bounded number of times with backoff.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Idempotency](/records/architecture/idempotency), [Timeout](/records/lexicon/timeout), [Backoff](/records/lexicon/backoff)", "term": "Requires" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Transient Failure Recovery](/records/lexicon/transient-failure-recovery)", "term": "Enables" }, { "description": "[Load Amplification](/records/lexicon/load-amplification)", "term": "In tension with" }, { "description": "[Non-Idempotent Operation](/records/lexicon/non-idempotent-operation)", "term": "Conflicts with" }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Referenced by" }, { "description": "[Retry Pattern / Load Amplification](/records/tension/load-amplification-retry-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Retry](/records/lexicon/unbounded-retry), [Retry Storm](/records/architecture/retry-storm)", "term": "Violated by" }, { "description": "retry loops without timeout/backoff", "term": "Detected by" }, { "description": "retry success rate, retry storm rate", "term": "Measured by" }, { "description": "[Backoff](/records/lexicon/backoff), [Idempotency Key](/records/lexicon/idempotency-key)", "term": "Refactored by" }, { "description": "resilience libraries, policy checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await remoteFoo.save(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await retry.withBackoff(\n () => remoteFoo.save(foo),\n { attempts: 3, retryIf: isTransientError, jitter: true },\n);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "resilience libraries, policy checks", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Idempotency](/records/architecture/idempotency), [Timeout](/records/lexicon/timeout), [Backoff](/records/lexicon/backoff), [Fault Tolerance](/records/architecture/fault-tolerance), [Transient Failure Recovery](/records/lexicon/transient-failure-recovery)", "term": "Depends on" }, { "description": "[Non-Idempotent Operation](/records/lexicon/non-idempotent-operation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-retry-pattern", "title": "Retry Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: network, IO, dependency call", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that gives every external call a time budget and fails the call when the budget runs out.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Time Budget](/records/lexicon/time-budget)", "term": "Requires" }, { "description": "[Fault Isolation](/records/lexicon/fault-isolation)", "term": "Reinforces" }, { "description": "[Bounded Waiting](/records/lexicon/bounded-waiting)", "term": "Enables" }, { "description": "[Slow Operation Tolerance](/records/lexicon/slow-operation-tolerance)", "term": "In tension with" }, { "description": "[Timeout Omission](/records/architecture/timeout-omission)", "term": "Conflicts with" }, { "description": "[Timeout Pattern / Slow Operation Tolerance](/records/tension/slow-operation-tolerance-timeout-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Timeout Omission](/records/architecture/timeout-omission)", "term": "Violated by" }, { "description": "missing timeout config", "term": "Detected by" }, { "description": "timeout coverage, latency tail", "term": "Measured by" }, { "description": "[Deadline Propagation](/records/lexicon/deadline-propagation)", "term": "Refactored by" }, { "description": "lint/config checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await remoteFoo.find(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await withTimeout(remoteFoo.find(id), 500, () => new FooTimeoutError(id));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint/config checks", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Time Budget](/records/lexicon/time-budget), [Fault Isolation](/records/lexicon/fault-isolation), [Bounded Waiting](/records/lexicon/bounded-waiting)", "term": "Depends on" }, { "description": "[Timeout Omission](/records/architecture/timeout-omission), [Timeout Omission](/records/architecture/timeout-omission)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-timeout-pattern", "title": "Timeout Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: dependency call, service", "Aliases: Circuit Breaker", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that stops calling a dependency after repeated failures and probes it again after a wait.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Failure Threshold](/records/lexicon/failure-threshold), [Fallback](/records/lexicon/fallback)", "term": "Requires" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Backpressure](/records/architecture/backpressure)", "term": "Reinforces" }, { "description": "[Cascading Failure Prevention](/records/lexicon/cascading-failure-prevention)", "term": "Enables" }, { "description": "[Availability of Degraded Dependency](/records/lexicon/availability-of-degraded-dependency)", "term": "In tension with" }, { "description": "[Unbounded Retry](/records/lexicon/unbounded-retry), [Retry Storm](/records/architecture/retry-storm)", "term": "Conflicts with" }, { "description": "[Circuit Breaker Pattern / Availability of Degraded Dependency](/records/tension/availability-of-degraded-dependency-circuit-breaker-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Failure Propagation](/records/lexicon/failure-propagation)", "term": "Violated by" }, { "description": "high failure dependency calls without breaker", "term": "Detected by" }, { "description": "breaker trip rate, downstream error rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[resilience policy](/records/algorithms/resilience-policy)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function loadFoo(id: FooId) { return remoteFoo.find(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooBreaker = new CircuitBreaker({ failureThreshold: 5, resetAfterMs: 30_000 });\nasync function loadFoo(id: FooId) {\n return fooBreaker.execute(() => remoteFoo.find(id));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "resilience policy", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Failure Threshold](/records/lexicon/failure-threshold), [Fallback](/records/lexicon/fallback), [Fault Tolerance](/records/architecture/fault-tolerance), [Backpressure](/records/architecture/backpressure), [Cascading Failure Prevention](/records/lexicon/cascading-failure-prevention)", "term": "Depends on" }, { "description": "[Unbounded Retry](/records/lexicon/unbounded-retry), [Retry Storm](/records/architecture/retry-storm)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-circuit-breaker-pattern", "title": "Circuit Breaker Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: resource pool, service, runtime", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that gives each workload its own pool of threads or connections, so one workload cannot exhaust the others.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Resource Isolation](/records/lexicon/resource-isolation)", "term": "Requires" }, { "description": "[Fault Isolation](/records/lexicon/fault-isolation)", "term": "Reinforces" }, { "description": "[Blast-Radius Reduction](/records/lexicon/blast-radius-reduction)", "term": "Enables" }, { "description": "[Resource Utilization](/records/architecture/resource-utilization)", "term": "In tension with" }, { "description": "[Shared Resource Pool](/records/lexicon/shared-resource-pool)", "term": "Conflicts with" }, { "description": "[Bulkhead Pattern / Resource Utilization](/records/tension/bulkhead-pattern-resource-utilization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Resource Pool](/records/lexicon/shared-resource-pool)", "term": "Violated by" }, { "description": "shared pools across critical/noncritical workloads", "term": "Detected by" }, { "description": "resource saturation isolation", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "resource policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const pool = new WorkerPool(100);\npool.submit(fooTask);\npool.submit(barTask);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooPool = new WorkerPool(20);\nconst barPool = new WorkerPool(20);\nfooPool.submit(fooTask);\nbarPool.submit(barTask);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "resource policy", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Resource Isolation](/records/lexicon/resource-isolation), [Fault Isolation](/records/lexicon/fault-isolation), [Blast-Radius Reduction](/records/lexicon/blast-radius-reduction)", "term": "Depends on" }, { "description": "[Shared Resource Pool](/records/lexicon/shared-resource-pool)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-bulkhead-pattern", "title": "Bulkhead Pattern" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Error Handling / Resilience](/records/architecture-category/error-handling-resilience)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: high-load systems", "Scope: stream, queue, service", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a consumer signal its capacity, so a producer slows down when the consumer falls behind.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Capacity Signaling](/records/lexicon/capacity-signaling)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Stability](/records/lexicon/stability)", "term": "Reinforces" }, { "description": "[Overload Protection](/records/lexicon/overload-protection)", "term": "Enables" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "In tension with" }, { "description": "[Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Conflicts with" }, { "description": "[Message Queue](/records/architecture/message-queue), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern), [Rate Limiting](/records/architecture/rate-limiting), [Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Referenced by" }, { "description": "[Backpressure / Throughput](/records/tension/backpressure-throughput)", "term": "Tensions" }, { "description": "[Event Stream](/records/architecture/event-stream): Backpressure is a consumer slowing its producer, while an event stream is the replayable log consumers read from their own offset.", "term": "Distinct from" }, { "description": "[Message Queue](/records/architecture/message-queue): Backpressure signals capacity back to the producer, while a message queue holds messages until a consumer takes them.", "term": "Distinct from" }, { "description": "[Rate Limiting](/records/architecture/rate-limiting): Backpressure slows a producer by the consumer's live capacity, while rate limiting caps a caller at a fixed rate and rejects the excess.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Violated by" }, { "description": "queue growth without throttling", "term": "Detected by" }, { "description": "queue depth, rejection/throttle rate", "term": "Measured by" }, { "description": "[Rate Limiting](/records/architecture/rate-limiting), [Bounded Queue](/records/lexicon/bounded-queue), [Autoscaling Policy](/records/lexicon/autoscaling-policy)", "term": "Refactored by" }, { "description": "load tests, runtime policies", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "stream.on(\"data\", foo => processFoo(foo));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for await (const foo of stream) {\n await capacity.acquire();\n void processFoo(foo).finally(() => capacity.release());\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "load tests, runtime policies", "term": "Checked by" }, { "description": "Every failure path: catch blocks, dependency calls, input boundaries and fallbacks", "term": "Population" }, { "description": "A verdict stands until a dependency, a failure path or the resilience policy changes", "term": "Freshness" }, { "description": "The lint rule, failure-injection test or policy check fails the change that leaves a failure path unhandled or unsafe", "term": "Refusal" }, { "description": "Catch blocks and dependency calls read from source, plus outcomes recorded by failure-injection runs", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The resilience policy, which every failure path conforms to", "term": "Authoritative side" }, { "description": "[Capacity Signaling](/records/lexicon/capacity-signaling), [Resilience](/records/architecture/resilience), [Stability](/records/lexicon/stability), [Overload Protection](/records/lexicon/overload-protection)", "term": "Depends on" }, { "description": "[Missing Backpressure](/records/architecture/missing-backpressure), [Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-backpressure", "title": "Backpressure" } ], "title": "Error Handling / Resilience" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_assessment[\"Assessment\"]\n n_architecture_review[\"Architecture Review\"]\n n_design_review[\"Design Review\"]\n n_code_review[\"Code Review\"]\n n_impact_analysis[\"Impact Analysis\"]\n n_gap_analysis[\"Gap Analysis\"]\n n_fitness_functions[\"Fitness Functions\"]\n n_quality_attributes[\"Quality Attributes\"]\n n_architecture_decision_records[\"Architecture Decision Records (ADR)\"]\n n_evolutionary_architecture[\"Evolutionary Architecture\"]\n n_minimum_viable_architecture[\"Minimum Viable Architecture\"]\n n_greenfield_development[\"Greenfield Development\"]\n n_first_principles_design[\"First-Principles Design\"]\n n_reference_architecture[\"Reference Architecture\"]\n n_pattern_consistency[\"Pattern Consistency\"]\n n_architectural_consistency[\"Architectural Consistency\"]\n n_standardization[\"Standardization\"]\n n_assessment --> n_quality_attributes\n n_architecture_review --> n_architecture_decision_records\n n_architecture_review --> n_architectural_consistency\n n_fitness_functions --> n_evolutionary_architecture\n n_quality_attributes --> n_architecture_review\n n_evolutionary_architecture --> n_fitness_functions\n n_greenfield_development --> n_first_principles_design\n n_reference_architecture --> n_standardization\n n_architectural_consistency --> n_pattern_consistency" } ], "icon": "bi-collection", "id": "architecture-category-architecture-review-evolution-governance-artifacts", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: codebase, architecture, risk", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of evaluating a codebase or architecture against stated criteria, using collected evidence.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Criteria](/records/lexicon/criteria), [Evidence](/records/lexicon/evidence)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance), [Quality Attributes](/records/architecture/quality-attributes)", "term": "Reinforces" }, { "description": "[Prioritized Refactoring](/records/lexicon/prioritized-refactoring)", "term": "Enables" }, { "description": "[Time Cost](/records/lexicon/time-cost)", "term": "In tension with" }, { "description": "[Assumption-Based Judgment](/records/lexicon/assumption-based-judgment)", "term": "Conflicts with" }, { "description": "[Assessment / Time Cost](/records/tension/assessment-time-cost)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Assumption-Based Judgment](/records/lexicon/assumption-based-judgment)", "term": "Violated by" }, { "description": "missing evaluation artifacts", "term": "Detected by" }, { "description": "assessment coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "review process", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "approveFooArchitecture();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const assessment = assess(fooArchitecture, {\n dimensions: [\"modularity\", \"reliability\", \"security\", \"operability\"],\n evidence: collectArchitectureEvidence(fooSystem),\n});\nrequirePassingAssessment(assessment);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "review process", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Criteria](/records/lexicon/criteria), [Evidence](/records/lexicon/evidence), [Governance](/records/architecture/governance), [Quality Attributes](/records/architecture/quality-attributes), [Prioritized Refactoring](/records/lexicon/prioritized-refactoring)", "term": "Depends on" }, { "description": "[Assumption-Based Judgment](/records/lexicon/assumption-based-judgment)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-assessment", "title": "Assessment" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: system, component, design change", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of examining a structural change against the architecture's criteria and recorded decisions before it is accepted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Architecture Criteria](/records/lexicon/architecture-criteria), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Requires" }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Reinforces" }, { "description": "[Risk Detection](/records/lexicon/risk-detection)", "term": "Enables" }, { "description": "[Delivery Speed](/records/lexicon/delivery-speed)", "term": "In tension with" }, { "description": "[Unreviewed Structural Change](/records/lexicon/unreviewed-structural-change)", "term": "Conflicts with" }, { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Referenced by" }, { "description": "[Architecture Review / Delivery Speed](/records/tension/architecture-review-delivery-speed)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unreviewed Structural Change](/records/lexicon/unreviewed-structural-change)", "term": "Violated by" }, { "description": "unapproved dependency/style changes", "term": "Detected by" }, { "description": "review coverage", "term": "Measured by" }, { "description": "[Code Review](/records/architecture/code-review), [Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Refactored by" }, { "description": "pull request gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "mergeFooDesign();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const review = architectureReview({\n context: fooContext,\n decisions: fooDecisions,\n risks: fooRisks,\n qualityAttributes: fooQualityAttributes,\n});\nreview.requireApproval([\"architecture-owner\", \"security-owner\"]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "pull request gates", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Architecture Criteria](/records/lexicon/architecture-criteria), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Architectural Consistency](/records/architecture/architectural-consistency), [Risk Detection](/records/lexicon/risk-detection)", "term": "Depends on" }, { "description": "[Unreviewed Structural Change](/records/lexicon/unreviewed-structural-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-architecture-review", "title": "Architecture Review" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: component, module, feature", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of checking a component or feature design for contracts, failure modes and testability before it is built.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Design Criteria](/records/lexicon/design-criteria)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Maintainability](/records/lexicon/maintainability)", "term": "Reinforces" }, { "description": "[Early Defect Prevention](/records/lexicon/early-defect-prevention)", "term": "Enables" }, { "description": "[Iteration Speed](/records/lexicon/iteration-speed)", "term": "In tension with" }, { "description": "[Ad-Hoc Design](/records/lexicon/ad-hoc-design)", "term": "Conflicts with" }, { "description": "[Design Review / Iteration Speed](/records/tension/design-review-iteration-speed)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Design](/records/lexicon/ad-hoc-design)", "term": "Violated by" }, { "description": "missing design record", "term": "Detected by" }, { "description": "design review finding rate", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "review checklist", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "implementFooDesign(fooDesign);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const review = designReview(fooDesign, {\n contracts: validateContracts,\n failureModes: analyzeFailureModes,\n testability: assessTestability,\n});\nif (!review.approved) throw new Error(\"design rejected\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "review checklist", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Design Criteria](/records/lexicon/design-criteria), [Correctness](/records/architecture/correctness), [Maintainability](/records/lexicon/maintainability), [Early Defect Prevention](/records/lexicon/early-defect-prevention)", "term": "Depends on" }, { "description": "[Ad-Hoc Design](/records/lexicon/ad-hoc-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-design-review", "title": "Design Review" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: code change", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of having a second party read a code change against review standards before it merges.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Review Standards](/records/lexicon/review-standards)", "term": "Requires" }, { "description": "[Quality](/records/lexicon/quality), [Security](/records/lexicon/security), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Defect Detection](/records/lexicon/defect-detection)", "term": "Enables" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "In tension with" }, { "description": "[Direct-to-main Unreviewed Change](/records/lexicon/direct-to-main-unreviewed-change)", "term": "Conflicts with" }, { "description": "[Code Review / Throughput](/records/tension/code-review-throughput)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct-to-main Unreviewed Change](/records/lexicon/direct-to-main-unreviewed-change)", "term": "Violated by" }, { "description": "missing approval/review", "term": "Detected by" }, { "description": "review coverage, defect escape rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "branch protection", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "git.merge(fooChange);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const review = codeReview(fooChange);\nreview.require({ approvals: 2, passingChecks: [\"tests\", \"types\", \"security\", \"architecture\"] });\ngit.merge(review.approvedCommit);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "branch protection", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Review Standards](/records/lexicon/review-standards), [Quality](/records/lexicon/quality), [Security](/records/lexicon/security), [Consistency](/records/architecture/consistency), [Defect Detection](/records/lexicon/defect-detection)", "term": "Depends on" }, { "description": "[Direct-to-main Unreviewed Change](/records/lexicon/direct-to-main-unreviewed-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-code-review", "title": "Code Review" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: change, dependency graph, API", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of tracing a change through the dependency graph to find every consumer it affects.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Dependency Graph](/records/architecture/dependency-graph), [Contracts](/records/lexicon/contracts)", "term": "Requires" }, { "description": "[Change Safety](/records/lexicon/change-safety)", "term": "Reinforces" }, { "description": "[Regression Scope Selection](/records/lexicon/regression-scope-selection)", "term": "Enables" }, { "description": "[Analysis Overhead](/records/lexicon/analysis-overhead)", "term": "In tension with" }, { "description": "[Blind Change](/records/lexicon/blind-change)", "term": "Conflicts with" }, { "description": "[Causal Dependency](/records/architecture/causal-dependency), [Dependency Graph](/records/architecture/dependency-graph)", "term": "Referenced by" }, { "description": "[Impact Analysis / Analysis Overhead](/records/tension/analysis-overhead-impact-analysis)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blind Change](/records/lexicon/blind-change)", "term": "Violated by" }, { "description": "change touching dependencies without impact note", "term": "Detected by" }, { "description": "affected component count", "term": "Measured by" }, { "description": "[Unit Tests](/records/lexicon/unit-tests)", "term": "Refactored by" }, { "description": "PR template, dependency tooling", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "renameFooField(\"name\", \"label\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const impact = dependencyGraph.impactOf({\n contract: \"FooV1.name\",\n change: \"rename-to-label\",\n});\nfor (const consumer of impact.consumers) requireMigration(consumer);\nrenameFooField(\"name\", \"label\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "PR template, dependency tooling", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Dependency Graph](/records/architecture/dependency-graph), [Contracts](/records/lexicon/contracts), [Change Safety](/records/lexicon/change-safety), [Regression Scope Selection](/records/lexicon/regression-scope-selection)", "term": "Depends on" }, { "description": "[Blind Change](/records/lexicon/blind-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-impact-analysis", "title": "Impact Analysis" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: compliance, architecture, capability", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The activity of comparing the current state of a system with its target state and listing each difference.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Target State](/records/lexicon/target-state), [Current State](/records/lexicon/current-state)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance)", "term": "Reinforces" }, { "description": "[Remediation Planning](/records/lexicon/remediation-planning)", "term": "Enables" }, { "description": "[Time Cost](/records/lexicon/time-cost)", "term": "In tension with" }, { "description": "[Undefined Target](/records/lexicon/undefined-target)", "term": "Conflicts with" }, { "description": "[Gap Analysis / Time Cost](/records/tension/gap-analysis-time-cost)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Undefined Target](/records/lexicon/undefined-target)", "term": "Violated by" }, { "description": "unknown compliance/architecture status", "term": "Detected by" }, { "description": "gap count/severity", "term": "Measured by" }, { "description": "[Mitigation Plan](/records/lexicon/mitigation-plan)", "term": "Refactored by" }, { "description": "governance process", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "declareFooSystemReady();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const target = fooTargetArchitecture();\nconst current = inspectFooArchitecture();\nconst gaps = compareArchitecture(current, target);\nfor (const gap of gaps) assignRemediation(gap);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "governance process", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Target State](/records/lexicon/target-state), [Current State](/records/lexicon/current-state), [Governance](/records/architecture/governance), [Remediation Planning](/records/lexicon/remediation-planning)", "term": "Depends on" }, { "description": "[Undefined Target](/records/lexicon/undefined-target)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-gap-analysis", "title": "Gap Analysis" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: codebase, pipeline, architecture", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that turns an architecture rule into an executable check the pipeline runs on every change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Measurable Architecture Rule](/records/lexicon/measurable-architecture-rule)", "term": "Requires" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Reinforces" }, { "description": "[Automated Architecture Compliance](/records/lexicon/automated-architecture-compliance)", "term": "Enables" }, { "description": "[Rule Maintenance](/records/lexicon/rule-maintenance)", "term": "In tension with" }, { "description": "[Manual Architecture Review Only](/records/lexicon/manual-architecture-review-only)", "term": "Conflicts with" }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture), [Stated Invariant](/records/architecture/stated-invariant), [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Referenced by" }, { "description": "[Enforcement Core](/records/algorithms/enforcement-core)", "term": "Contracts" }, { "description": "[Fitness Functions / Rule Maintenance](/records/tension/fitness-functions-rule-maintenance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Violated by" }, { "description": "missing executable architecture checks", "term": "Detected by" }, { "description": "fitness pass/fail trend", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "CI architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "architectureGuidelines.write(\"Foo domain must not import infrastructure\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fitness = forbidImports({ from: \"src/foo/domain/**\", to: \"src/foo/infrastructure/**\" });\npipeline.enforce(fitness);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI architecture tests", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Measurable Architecture Rule](/records/lexicon/measurable-architecture-rule), [Evolutionary Architecture](/records/architecture/evolutionary-architecture), [Automated Architecture Compliance](/records/lexicon/automated-architecture-compliance)", "term": "Depends on" }, { "description": "[Manual Architecture Review Only](/records/lexicon/manual-architecture-review-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fitness-functions", "title": "Fitness Functions" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: system, service, codebase", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the non-functional properties a system must meet, each stated as a measurable scenario.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Attribute Scenarios](/records/lexicon/attribute-scenarios)", "term": "Requires" }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Reinforces" }, { "description": "[Trade-Off Analysis](/records/lexicon/trade-off-analysis)", "term": "Enables" }, { "description": "[Competing Attributes](/records/lexicon/competing-attributes)", "term": "In tension with" }, { "description": "[Feature-Only Design](/records/architecture/feature-only-design)", "term": "Conflicts with" }, { "description": "[Assessment](/records/architecture/assessment)", "term": "Referenced by" }, { "description": "[Quality Attributes / Competing Attributes](/records/tension/competing-attributes-quality-attributes)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Feature-Only Design](/records/architecture/feature-only-design)", "term": "Violated by" }, { "description": "missing quality scenarios/SLOs", "term": "Detected by" }, { "description": "quality attribute scenario pass rate", "term": "Measured by" }, { "description": "[Quality Scenarios](/records/lexicon/quality-scenarios), [Fitness Functions](/records/architecture/fitness-functions)", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "designFooService();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const attributes = defineQualityAttributes({\n availability: \"99.95%\",\n p95LatencyMs: 200,\n recoveryTimeMinutes: 5,\n dataLossSeconds: 0,\n});\ndesignFooService(attributes);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Attribute Scenarios](/records/lexicon/attribute-scenarios), [Architecture Review](/records/architecture/architecture-review), [Trade-Off Analysis](/records/lexicon/trade-off-analysis)", "term": "Depends on" }, { "description": "[Feature-Only Design](/records/architecture/feature-only-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-quality-attributes", "title": "Quality Attributes" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: architecture decision", "Aliases: ADRs", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of one architecture decision, recording its context, the choice made and its consequences.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Context](/records/lexicon/context), [Decision](/records/lexicon/decision), [Consequences](/records/lexicon/consequences)", "term": "Requires" }, { "description": "[Traceability](/records/architecture/traceability), [Governance](/records/architecture/governance)", "term": "Reinforces" }, { "description": "[Decision History](/records/lexicon/decision-history)", "term": "Enables" }, { "description": "[Documentation Maintenance](/records/lexicon/documentation-maintenance)", "term": "In tension with" }, { "description": "[Tribal Knowledge](/records/lexicon/tribal-knowledge)", "term": "Conflicts with" }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Referenced by" }, { "description": "[Architecture Decision Records (ADR) / Documentation Maintenance](/records/tension/architecture-decision-records-adr-documentation-maintenance)", "term": "Tensions" }, { "description": "[Consequences](/records/lexicon/consequences): A decision record is the whole record, while its consequences are the one part that states the trade-offs and effects.", "term": "Distinct from" }, { "description": "[Decision](/records/lexicon/decision): A decision record is the whole record, while the decision is the one part that states the choice made.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Tribal Knowledge](/records/lexicon/tribal-knowledge)", "term": "Violated by" }, { "description": "architecture change without ADR", "term": "Detected by" }, { "description": "ADR coverage", "term": "Measured by" }, { "description": "[Decision Record with Alternatives](/records/lexicon/decision-record-with-alternatives), [Data Change Audit](/records/lexicon/data-change-audit)", "term": "Refactored by" }, { "description": "PR template, review policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "chooseFooDatabase(\"postgres\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const adr = recordDecision({\n id: \"ADR-0042\",\n title: \"Use PostgreSQL for Foo persistence\",\n status: \"accepted\",\n context: fooPersistenceForces,\n decision: \"postgres\",\n consequences: fooPersistenceConsequences,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "PR template, review policy", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Context](/records/lexicon/context), [Decision](/records/lexicon/decision), [Consequences](/records/lexicon/consequences), [Traceability](/records/architecture/traceability), [Governance](/records/architecture/governance), [Decision History](/records/lexicon/decision-history)", "term": "Depends on" }, { "description": "[Tribal Knowledge](/records/lexicon/tribal-knowledge)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-architecture-decision-records", "title": "Architecture Decision Records (ADR)" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, codebase", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which the architecture changes in small increments, each guarded by fitness functions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Fitness Functions](/records/architecture/fitness-functions), [Incremental Change](/records/lexicon/incremental-change)", "term": "Requires" }, { "description": "[Continuous Improvement](/records/lexicon/continuous-improvement)", "term": "Reinforces" }, { "description": "[Controlled Architecture Evolution](/records/lexicon/controlled-architecture-evolution)", "term": "Enables" }, { "description": "[Governance Discipline](/records/lexicon/governance-discipline)", "term": "In tension with" }, { "description": "[Big-Upfront Frozen Architecture](/records/architecture/big-upfront-frozen-architecture), [Lava Flow](/records/architecture/lava-flow), [Premature Abstraction](/records/architecture/premature-abstraction), [Zombie Code](/records/architecture/zombie-code)", "term": "Conflicts with" }, { "description": "[Forward Compatibility](/records/architecture/forward-compatibility), [Fitness Functions](/records/architecture/fitness-functions)", "term": "Referenced by" }, { "description": "[Evolution Principles](/records/algorithms/evolution-principles)", "term": "Contracts" }, { "description": "[Evolutionary Architecture / Governance Discipline](/records/tension/evolutionary-architecture-governance-discipline)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Architecture Drift](/records/lexicon/architecture-drift)", "term": "Violated by" }, { "description": "accumulating unmeasured drift", "term": "Detected by" }, { "description": "fitness trend, architecture debt", "term": "Measured by" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions), [Small-Batch Release](/records/lexicon/small-batch-release)", "term": "Refactored by" }, { "description": "CI/CD architecture checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "designFinalFooArchitecture();\nfreezeArchitectureForever();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooArchitecture = evolveArchitecture({\n current: minimumFooArchitecture,\n fitnessFunctions: fooFitnessFunctions,\n nextChange: highestValueArchitectureChange,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI/CD architecture checks", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions), [Incremental Change](/records/lexicon/incremental-change), [Continuous Improvement](/records/lexicon/continuous-improvement), [Controlled Architecture Evolution](/records/lexicon/controlled-architecture-evolution)", "term": "Depends on" }, { "description": "[Big-Upfront Frozen Architecture](/records/architecture/big-upfront-frozen-architecture), [Lava Flow](/records/architecture/lava-flow), [Premature Abstraction](/records/architecture/premature-abstraction), [Zombie Code](/records/architecture/zombie-code)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-evolutionary-architecture", "title": "Evolutionary Architecture" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: greenfield, early product", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which a system starts with only the structure its current quality attributes require, and defers the rest until a force demands it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Essential Quality Attributes](/records/lexicon/essential-quality-attributes)", "term": "Requires" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "Reinforces" }, { "description": "[Early Delivery with Guardrails](/records/lexicon/early-delivery-with-guardrails)", "term": "Enables" }, { "description": "[Future Scalability](/records/lexicon/future-scalability)", "term": "In tension with" }, { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut), [Over-Abstraction](/records/architecture/over-abstraction), [Speculative Generality](/records/architecture/speculative-generality)", "term": "Conflicts with" }, { "description": "[Minimum Viable Architecture / Future Scalability](/records/tension/future-scalability-minimum-viable-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Speculative Generality](/records/architecture/speculative-generality)", "term": "Violated by" }, { "description": "unused abstractions/infrastructure", "term": "Detected by" }, { "description": "architecture complexity vs need", "term": "Measured by" }, { "description": "[Cleanup / Simplification](/records/lexicon/cleanup-simplification), [Defer Generalization](/records/lexicon/defer-generalization)", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "buildServiceMesh();\nbuildGlobalEventBus();\nbuildPluginPlatform();\ncreateFooEndpoint();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const architecture = defineMinimumArchitecture({\n useCase: \"create-and-read-foo\",\n components: [\"foo-api\", \"foo-store\"],\n deferredUntilForced: [\"service-mesh\", \"plugin-platform\"],\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Essential Quality Attributes](/records/lexicon/essential-quality-attributes), [Simplicity](/records/lexicon/simplicity), [Early Delivery with Guardrails](/records/lexicon/early-delivery-with-guardrails)", "term": "Depends on" }, { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut), [Architecture Astronaut](/records/architecture/architecture-astronaut), [Over-Abstraction](/records/architecture/over-abstraction), [Speculative Generality](/records/architecture/speculative-generality)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-minimum-viable-architecture", "title": "Minimum Viable Architecture" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: new codebase, system", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "An abstraction of building a new system with no inherited code, so its boundaries are designed from the current forces.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Requires" }, { "description": "[Architecture Foundation](/records/lexicon/architecture-foundation)", "term": "Reinforces" }, { "description": "[Clean Boundary Design](/records/lexicon/clean-boundary-design)", "term": "Enables" }, { "description": "[Unknown Requirements](/records/lexicon/unknown-requirements), [Legacy Constraints](/records/lexicon/legacy-constraints)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Greenfield Development / Unknown Requirements](/records/tension/greenfield-development-unknown-requirements), [Greenfield Development / Legacy Constraints](/records/tension/greenfield-development-legacy-constraints)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Big-Upfront Frozen Architecture](/records/architecture/big-upfront-frozen-architecture)", "term": "Violated by" }, { "description": "heavy structure without validated need", "term": "Detected by" }, { "description": "[initial complexity](/records/lexicon/initial-complexity), adaptability", "term": "Measured by" }, { "description": "[Define Module Boundaries](/records/lexicon/define-module-boundaries), [Decision Record with Alternatives](/records/lexicon/decision-record-with-alternatives)", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "copyLegacyFooModule();\nretainLegacyFooFlags();\nretainLegacyFooSchema();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooSystem = designFromCurrentForces({\n domain: fooDomain,\n constraints: currentConstraints,\n contracts: currentContracts,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[First-Principles Design](/records/architecture/first-principles-design), [Architecture Foundation](/records/lexicon/architecture-foundation), [Clean Boundary Design](/records/lexicon/clean-boundary-design)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-greenfield-development", "title": "Greenfield Development" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: architecture, domain, component", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which a design is derived from the problem's forces and invariants before any known pattern is chosen.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Problem Decomposition](/records/lexicon/problem-decomposition)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Simplicity](/records/lexicon/simplicity)", "term": "Reinforces" }, { "description": "[Fit-for-Purpose Architecture](/records/lexicon/fit-for-purpose-architecture)", "term": "Enables" }, { "description": "[Reuse of Established Patterns](/records/lexicon/reuse-of-established-patterns)", "term": "In tension with" }, { "description": "[Pattern Cargo Cult](/records/architecture/pattern-cargo-cult), [Golden Hammer](/records/architecture/golden-hammer)", "term": "Conflicts with" }, { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Referenced by" }, { "description": "[Design Patterns Core](/records/algorithms/design-patterns-core)", "term": "Contracts" }, { "description": "[First-Principles Design / Reuse of Established Patterns](/records/tension/first-principles-design-reuse-of-established-patterns)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Golden Hammer](/records/architecture/golden-hammer)", "term": "Violated by" }, { "description": "unjustified pattern selection", "term": "Detected by" }, { "description": "decision rationale quality", "term": "Measured by" }, { "description": "[Decision Review](/records/lexicon/decision-review), [Remove Pattern Shell](/records/lexicon/remove-pattern-shell)", "term": "Refactored by" }, { "description": "ADR review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "useMicroservicesBecauseIndustryUsesMicroservices();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const forces = identifyForces(fooProblem);\nconst invariants = deriveInvariants(forces);\nconst design = synthesizeArchitecture({ forces, invariants });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "ADR review", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Problem Decomposition](/records/lexicon/problem-decomposition), [Correctness](/records/architecture/correctness), [Simplicity](/records/lexicon/simplicity), [Fit-for-Purpose Architecture](/records/lexicon/fit-for-purpose-architecture)", "term": "Depends on" }, { "description": "[Pattern Cargo Cult](/records/architecture/pattern-cargo-cult), [Golden Hammer](/records/architecture/golden-hammer), [Pattern Cargo Cult](/records/architecture/pattern-cargo-cult)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-first-principles-design", "title": "First-Principles Design" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: platform, organization, system family", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the modules, patterns and allowed dependencies that a family of systems instantiates.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Standard Patterns](/records/lexicon/standard-patterns), [Quality Goals](/records/lexicon/quality-goals)", "term": "Requires" }, { "description": "[Standardization](/records/architecture/standardization), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Reusable Architecture Guidance](/records/lexicon/reusable-architecture-guidance)", "term": "Enables" }, { "description": "[Team Autonomy](/records/lexicon/team-autonomy)", "term": "In tension with" }, { "description": "[Uncoordinated Divergence](/records/lexicon/uncoordinated-divergence)", "term": "Conflicts with" }, { "description": "[Reference Architecture / Team Autonomy](/records/tension/reference-architecture-team-autonomy)", "term": "Tensions" }, { "description": "[Reusable Architecture Guidance](/records/lexicon/reusable-architecture-guidance): A reference architecture defines the modules and dependencies a family of systems instantiates, while reusable guidance is the wider body of advice it packages.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Uncoordinated Divergence](/records/lexicon/uncoordinated-divergence)", "term": "Violated by" }, { "description": "deviation without ADR", "term": "Detected by" }, { "description": "conformance/deviation rate", "term": "Measured by" }, { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "teamA.buildFooOneWay();\nteamB.buildFooAnotherWay();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooReference = defineReferenceArchitecture({\n modules: [\"api\", \"application\", \"domain\", \"adapters\"],\n allowedDependencies: fooDependencyRules,\n});\nteamA.instantiate(fooReference);\nteamB.instantiate(fooReference);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Standard Patterns](/records/lexicon/standard-patterns), [Quality Goals](/records/lexicon/quality-goals), [Standardization](/records/architecture/standardization), [Consistency](/records/architecture/consistency), [Reusable Architecture Guidance](/records/lexicon/reusable-architecture-guidance)", "term": "Depends on" }, { "description": "[Uncoordinated Divergence](/records/lexicon/uncoordinated-divergence)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-reference-architecture", "title": "Reference Architecture" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: codebase, system", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which one kind of problem is solved with the same pattern throughout a codebase.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Naming/Structure Conventions](/records/lexicon/naming-structure-conventions)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Maintainability](/records/lexicon/maintainability)", "term": "Reinforces" }, { "description": "[Easier Refactoring](/records/lexicon/easier-refactoring)", "term": "Enables" }, { "description": "[Local Optimization](/records/lexicon/local-optimization)", "term": "In tension with" }, { "description": "[Ad-Hoc Pattern Mixing](/records/lexicon/ad-hoc-pattern-mixing)", "term": "Conflicts with" }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency), [Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Referenced by" }, { "description": "[Pattern Consistency / Local Optimization](/records/tension/local-optimization-pattern-consistency)", "term": "Tensions" }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency): Pattern consistency is one problem solved one way everywhere, while architectural consistency is code following the declared boundaries and layers.", "term": "Distinct from" }, { "description": "[Local Optimization](/records/lexicon/local-optimization): Pattern consistency is the degree shared patterns are used, while local optimization is the one-off gain that using them gives up.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Pattern Mixing](/records/lexicon/ad-hoc-pattern-mixing)", "term": "Violated by" }, { "description": "inconsistent implementations of same concern", "term": "Detected by" }, { "description": "pattern variance count", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface)", "term": "Refactored by" }, { "description": "linting, [review](/records/lexicon/review), scaffolding", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooModule.useRepository();\nbarModule.queryDatabaseDirectly();\nbazModule.useActiveRecord();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const persistencePattern = \"repository\" as const;\nfooModule.use(persistencePattern);\nbarModule.use(persistencePattern);\nbazModule.use(persistencePattern);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "linting, review, scaffolding", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Naming/Structure Conventions](/records/lexicon/naming-structure-conventions), [Predictability](/records/architecture/predictability), [Maintainability](/records/lexicon/maintainability), [Easier Refactoring](/records/lexicon/easier-refactoring)", "term": "Depends on" }, { "description": "[Ad-Hoc Pattern Mixing](/records/lexicon/ad-hoc-pattern-mixing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pattern-consistency", "title": "Pattern Consistency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: system, codebase", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the code follows the system's declared boundaries, layers and dependency rules.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Architecture Rules](/records/lexicon/architecture-rules), [Governance](/records/architecture/governance)", "term": "Requires" }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Reinforces" }, { "description": "[Predictable Evolution](/records/lexicon/predictable-evolution)", "term": "Enables" }, { "description": "[Local Autonomy](/records/lexicon/local-autonomy)", "term": "In tension with" }, { "description": "[Architecture Drift](/records/lexicon/architecture-drift)", "term": "Conflicts with" }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Referenced by" }, { "description": "[Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Contracts" }, { "description": "[Architectural Consistency / Local Autonomy](/records/tension/architectural-consistency-local-autonomy)", "term": "Tensions" }, { "description": "[Local Autonomy](/records/lexicon/local-autonomy): Architectural consistency is the degree the code follows declared rules, while local autonomy is the team freedom that enforcing them costs.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Architecture Drift](/records/lexicon/architecture-drift)", "term": "Violated by" }, { "description": "architecture fitness failures", "term": "Detected by" }, { "description": "violation trend", "term": "Measured by" }, { "description": "[Architecture Test](/records/lexicon/architecture-test)", "term": "Refactored by" }, { "description": "architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooDomain.imports(sqlClient);\nbarDomain.imports(httpClient);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "architectureRules.enforce([\n forbid(\"domain\", \"infrastructure\"),\n requirePortFor(\"external-io\"),\n]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Architecture Rules](/records/lexicon/architecture-rules), [Governance](/records/architecture/governance), [Pattern Consistency](/records/architecture/pattern-consistency), [Predictable Evolution](/records/lexicon/predictable-evolution)", "term": "Depends on" }, { "description": "[Architecture Drift](/records/lexicon/architecture-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-architectural-consistency", "title": "Architectural Consistency" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Architecture Review / Evolution / Governance Artifacts](/records/architecture-category/architecture-review-evolution-governance-artifacts)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: codebase, platform, organization", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that one format, tool or pattern is chosen for each recurring concern and applied everywhere it occurs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Standards Definition](/records/lexicon/standards-definition)", "term": "Requires" }, { "description": "[Consistency](/records/architecture/consistency), [Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Reuse](/records/lexicon/reuse), [Operability](/records/lexicon/operability)", "term": "Enables" }, { "description": "[Innovation/Autonomy](/records/lexicon/innovation-autonomy)", "term": "In tension with" }, { "description": "[Unbounded Variation](/records/lexicon/unbounded-variation)", "term": "Conflicts with" }, { "description": "[Autonomy](/records/architecture/autonomy), [Reference Architecture](/records/architecture/reference-architecture)", "term": "Referenced by" }, { "description": "[Standardization / Innovation/Autonomy](/records/tension/innovation-autonomy-standardization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Inconsistent Conventions](/records/lexicon/inconsistent-conventions)", "term": "Violated by" }, { "description": "standards deviation", "term": "Detected by" }, { "description": "conformance rate", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface)", "term": "Refactored by" }, { "description": "CI policies, templates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "teamA.emit({ foo_id: foo.id });\nteamB.emit({ id: foo.id, type: \"foo\" });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FooCreatedV1 = standardEvent({\n type: \"FooCreated\",\n version: 1,\n fields: { fooId: FooIdSchema },\n});\nteamA.emit(FooCreatedV1.create(foo));\nteamB.emit(FooCreatedV1.create(foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI policies, templates", "term": "Checked by" }, { "description": "Every architecture change, decision and deviation the review or gate is asked to pass", "term": "Population" }, { "description": "A verdict stands for the change it reviewed and goes stale when the architecture, the criteria or the decision record changes", "term": "Freshness" }, { "description": "The gate or the reviewer withholds approval, so the change does not merge", "term": "Refusal" }, { "description": "The recorded review, decision record or fitness run attached to the change", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The decision record and the review criteria, which a change is compared against", "term": "Authoritative side" }, { "description": "[Standards Definition](/records/lexicon/standards-definition), [Consistency](/records/architecture/consistency), [Interoperability](/records/architecture/interoperability), [Reuse](/records/lexicon/reuse), [Operability](/records/lexicon/operability)", "term": "Depends on" }, { "description": "[Unbounded Variation](/records/lexicon/unbounded-variation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-standardization", "title": "Standardization" } ], "title": "Architecture Review / Evolution / Governance Artifacts" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_self_describing_architecture[\"Self-Describing Architecture\"]\n n_self_describing_api[\"Self-Describing API\"]\n n_self_describing_structures[\"Self-Describing Structures\"]\n n_metadata_driven_design[\"Metadata-Driven Design\"]\n n_declarative_configuration[\"Declarative Configuration\"]\n n_convention_over_configuration[\"Convention over Configuration\"]\n n_capability_declaration[\"Capability Declaration\"]\n n_manifest_based_design[\"Manifest-Based Design\"]\n n_self_describing_architecture --> n_capability_declaration\n n_metadata_driven_design --> n_declarative_configuration\n n_manifest_based_design --> n_self_describing_architecture\n n_manifest_based_design --> n_capability_declaration" } ], "icon": "bi-collection", "id": "architecture-category-metadata-self-description-declarative-systems", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, runtime, integration", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each module declares its name, version, capabilities and requirements in metadata that tools and the runtime can read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Metadata](/records/lexicon/metadata), [Capability Declaration](/records/architecture/capability-declaration)", "term": "Requires" }, { "description": "[Discoverability](/records/lexicon/discoverability), [Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Reinforces" }, { "description": "[Plugin Architecture](/records/architecture/plugin-architecture), [Automation](/records/lexicon/automation)", "term": "Enables" }, { "description": "[Metadata Drift](/records/lexicon/metadata-drift)", "term": "In tension with" }, { "description": "[Hidden Runtime Behavior](/records/lexicon/hidden-runtime-behavior)", "term": "Conflicts with" }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" }, { "description": "[Self-Describing Architecture / Metadata Drift](/records/tension/metadata-drift-self-describing-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Runtime Behavior](/records/lexicon/hidden-runtime-behavior)", "term": "Violated by" }, { "description": "undocumented runtime capability", "term": "Detected by" }, { "description": "metadata coverage", "term": "Measured by" }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design), [Declare Capability](/records/lexicon/declare-capability), [Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "manifest validation, metadata tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const modules = [new FooModule(), new BarModule()];", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type ModuleDescriptor = { name: string; version: string; provides: readonly string[]; requires: readonly string[] };\nconst fooModule = defineModule({ name: \"foo\", version: \"1.0.0\", provides: [\"FooStore\"], requires: [\"EventBus\"] });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "manifest validation, metadata tests", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Metadata](/records/lexicon/metadata), [Capability Declaration](/records/architecture/capability-declaration), [Discoverability](/records/lexicon/discoverability), [Runtime Discovery](/records/architecture/runtime-discovery), [Plugin Architecture](/records/architecture/plugin-architecture), [Automation](/records/lexicon/automation)", "term": "Depends on" }, { "description": "[Hidden Runtime Behavior](/records/lexicon/hidden-runtime-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-self-describing-architecture", "title": "Self-Describing Architecture" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, integration", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an API publishes machine-readable descriptions of its operations, payloads and errors.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract), [Metadata](/records/lexicon/metadata)", "term": "Requires" }, { "description": "[Discoverability](/records/lexicon/discoverability), [Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Client Generation](/records/lexicon/client-generation), [HATEOAS-style Navigation](/records/lexicon/hateoas-style-navigation)", "term": "Enables" }, { "description": "[Payload Verbosity](/records/lexicon/payload-verbosity)", "term": "In tension with" }, { "description": "[Opaque API](/records/lexicon/opaque-api)", "term": "Conflicts with" }, { "description": "[Self-Describing API / Payload Verbosity](/records/tension/payload-verbosity-self-describing-api)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque API](/records/lexicon/opaque-api)", "term": "Violated by" }, { "description": "missing OpenAPI/metadata", "term": "Detected by" }, { "description": "API documentation/contract coverage", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract), [Declare Capability](/records/lexicon/declare-capability), [Standard Error Contract](/records/lexicon/standard-error-contract)", "term": "Refactored by" }, { "description": "API linting, docs gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo\", createFoo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const createFooApi = defineEndpoint({\n method: \"POST\",\n path: \"/foos\",\n request: CreateFooSchema,\n response: FooCreatedSchema,\n errors: FooErrorSchema,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API linting, docs gates", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[API Contract](/records/architecture/api-contract), [Metadata](/records/lexicon/metadata), [Discoverability](/records/lexicon/discoverability), [Interoperability](/records/architecture/interoperability), [Client Generation](/records/lexicon/client-generation), [HATEOAS-style Navigation](/records/lexicon/hateoas-style-navigation)", "term": "Depends on" }, { "description": "[Opaque API](/records/lexicon/opaque-api)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-self-describing-api", "title": "Self-Describing API" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data, runtime, metadata", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a data structure carries its own type tags and field names, so a reader can interpret it without outside knowledge.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Type Metadata](/records/lexicon/type-metadata), [Schema](/records/lexicon/schema)", "term": "Requires" }, { "description": "[Introspection](/records/architecture/introspection), [Validation](/records/architecture/validation)", "term": "Reinforces" }, { "description": "[Dynamic Processing](/records/lexicon/dynamic-processing)", "term": "Enables" }, { "description": "[Size Overhead](/records/lexicon/size-overhead)", "term": "In tension with" }, { "description": "[Opaque Binary/Untyped Structures](/records/lexicon/opaque-binary-untyped-structures)", "term": "Conflicts with" }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Referenced by" }, { "description": "[Self-Describing Structures / Size Overhead](/records/tension/self-describing-structures-size-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Binary/Untyped Structures](/records/lexicon/opaque-binary-untyped-structures)", "term": "Violated by" }, { "description": "missing type/schema markers", "term": "Detected by" }, { "description": "metadata completeness", "term": "Measured by" }, { "description": "[Introduce Discriminated Union](/records/lexicon/introduce-discriminated-union), [Schema Validation](/records/architecture/schema-validation), [Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Refactored by" }, { "description": "[schema validation](/records/architecture/schema-validation)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const node = [\"foo\", \"foo_1\", 3, true];", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const node = { kind: \"foo\", id: \"foo_1\", count: 3, active: true } as const;", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema validation", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Type Metadata](/records/lexicon/type-metadata), [Schema](/records/lexicon/schema), [Introspection](/records/architecture/introspection), [Validation](/records/architecture/validation), [Dynamic Processing](/records/lexicon/dynamic-processing)", "term": "Depends on" }, { "description": "[Opaque Binary/Untyped Structures](/records/lexicon/opaque-binary-untyped-structures)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-self-describing-structures", "title": "Self-Describing Structures" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, configuration, framework", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which behavior such as forms, routes or plugins is generated from validated metadata instead of written case by case.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Metadata Schema](/records/lexicon/metadata-schema), [Validation](/records/architecture/validation)", "term": "Requires" }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration), [Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Reinforces" }, { "description": "[Code Generation](/records/lexicon/code-generation), [Plugins](/records/lexicon/plugins)", "term": "Enables" }, { "description": "[Debuggability](/records/lexicon/debuggability)", "term": "In tension with" }, { "description": "[Hardcoded Behavior](/records/lexicon/hardcoded-behavior)", "term": "Conflicts with" }, { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Referenced by" }, { "description": "[Metadata-Driven Design / Debuggability](/records/tension/debuggability-metadata-driven-design)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unvalidated Metadata](/records/lexicon/unvalidated-metadata), [Hidden Runtime Behavior](/records/lexicon/hidden-runtime-behavior)", "term": "Violated by" }, { "description": "metadata/config drift", "term": "Detected by" }, { "description": "metadata coverage, config error rate", "term": "Measured by" }, { "description": "[Declare Capability](/records/lexicon/declare-capability), [Schema Validation](/records/architecture/schema-validation), [Configuration Schema](/records/lexicon/configuration-schema)", "term": "Refactored by" }, { "description": "metadata schema tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (field === \"name\") renderText();\nif (field === \"count\") renderNumber();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooFields = {\n name: { kind: \"text\", required: true },\n count: { kind: \"integer\", min: 0 },\n} as const;\nrenderForm(fooFields);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "metadata schema tests", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Metadata Schema](/records/lexicon/metadata-schema), [Validation](/records/architecture/validation), [Declarative Configuration](/records/architecture/declarative-configuration), [Runtime Discovery](/records/architecture/runtime-discovery), [Code Generation](/records/lexicon/code-generation), [Plugins](/records/lexicon/plugins)", "term": "Depends on" }, { "description": "[Hardcoded Behavior](/records/lexicon/hardcoded-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-metadata-driven-design", "title": "Metadata-Driven Design" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: configuration, infrastructure, runtime", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a system's settings are declared as validated data, and the system configures itself from that data.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Schema Validation](/records/architecture/schema-validation), [Explicit Semantics](/records/lexicon/explicit-semantics)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Reinforces" }, { "description": "[Runtime Configuration without Code Change](/records/lexicon/runtime-configuration-without-code-change)", "term": "Enables" }, { "description": "[Dynamic Complexity](/records/lexicon/dynamic-complexity)", "term": "In tension with" }, { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Conflicts with" }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Domain-Specific Language (DSL)](/records/architecture/domain-specific-language), [Registry-Held Order](/records/architecture/registry-held-order)", "term": "Referenced by" }, { "description": "[Declarative Core](/records/algorithms/declarative-core)", "term": "Contracts" }, { "description": "[Declarative Configuration / Dynamic Complexity](/records/tension/declarative-configuration-dynamic-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Behavior](/records/lexicon/hardcoded-behavior)", "term": "Violated by" }, { "description": "hardcoded environment values", "term": "Detected by" }, { "description": "configuration externalization coverage", "term": "Measured by" }, { "description": "[Externalize Configuration](/records/lexicon/externalize-configuration), [Configuration Schema](/records/lexicon/configuration-schema)", "term": "Refactored by" }, { "description": "config linting, [validation](/records/architecture/validation)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const app = new FooApp();\napp.enableCache();\napp.setRetries(3);\napp.register(new BarPlugin());", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const config = defineFooConfig({\n cache: { enabled: true },\n retries: 3,\n plugins: [\"bar\"],\n});\nconst app = FooApp.fromConfig(config);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "config linting, validation", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Schema Validation](/records/architecture/schema-validation), [Explicit Semantics](/records/lexicon/explicit-semantics), [Predictability](/records/architecture/predictability), [Infrastructure as Code](/records/architecture/infrastructure-as-code), [Runtime Configuration without Code Change](/records/lexicon/runtime-configuration-without-code-change)", "term": "Depends on" }, { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-declarative-configuration", "title": "Declarative Configuration" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: framework, application structure", "Aliases: Coding by Convention", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a framework infers settings from stable naming and placement conventions, and explicit configuration covers only the exceptions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Conventions](/records/lexicon/stable-conventions)", "term": "Requires" }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency), [Predictability](/records/architecture/predictability)", "term": "Reinforces" }, { "description": "[Reduced Boilerplate](/records/lexicon/reduced-boilerplate)", "term": "Enables" }, { "description": "[Explicitness](/records/lexicon/explicitness)", "term": "In tension with" }, { "description": "[Excessive Configuration](/records/lexicon/excessive-configuration)", "term": "Conflicts with" }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Referenced by" }, { "description": "[Automation Kernel](/records/algorithms/automation-kernel)", "term": "Contracts" }, { "description": "[Convention over Configuration / Explicitness](/records/tension/convention-over-configuration-explicitness)", "term": "Tensions" }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures): Convention over configuration infers settings from naming and placement, while self-describing structures carry their own type tags and field names.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Inconsistent Conventions](/records/lexicon/inconsistent-conventions)", "term": "Violated by" }, { "description": "convention deviations", "term": "Detected by" }, { "description": "convention compliance score", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Centralize the Rule](/records/lexicon/centralize-the-rule)", "term": "Refactored by" }, { "description": "scaffolding, lint rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "registerHandler(\"foo\", \"./handlers/foo-handler\", \"FooHandler\");\nregisterHandler(\"bar\", \"./handlers/bar-handler\", \"BarHandler\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const handlers = discoverHandlers(\"./handlers/*.handler.ts\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "scaffolding, lint rules", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Stable Conventions](/records/lexicon/stable-conventions), [Pattern Consistency](/records/architecture/pattern-consistency), [Predictability](/records/architecture/predictability), [Reduced Boilerplate](/records/lexicon/reduced-boilerplate)", "term": "Depends on" }, { "description": "[Excessive Configuration](/records/lexicon/excessive-configuration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-convention-over-configuration", "title": "Convention over Configuration" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: plugin, service, runtime", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism by which a plugin or service lists the operations it supports, so callers test the list instead of probing for methods.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Manifest](/records/lexicon/manifest), [Contracts](/records/lexicon/contracts)", "term": "Requires" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Self-Description](/records/lexicon/self-description)", "term": "Reinforces" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Enables" }, { "description": "[Declaration Drift](/records/lexicon/declaration-drift)", "term": "In tension with" }, { "description": "[Implicit Capability](/records/lexicon/implicit-capability)", "term": "Conflicts with" }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" }, { "description": "[Capability Declaration / Declaration Drift](/records/tension/capability-declaration-declaration-drift)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implicit Capability](/records/lexicon/implicit-capability)", "term": "Violated by" }, { "description": "manifest-code mismatch", "term": "Detected by" }, { "description": "declared/actual capability match rate", "term": "Measured by" }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design), [Extract Role Interface](/records/lexicon/extract-role-interface)", "term": "Refactored by" }, { "description": "manifest validation, conformance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "try { await plugin.exportFoo(foo); } catch (error) { if (isMissingMethod(error)) return; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooPlugin = {\n capabilities: readonly (\"read\" | \"write\" | \"export\")[];\n exportFoo?: (foo: Foo) => Promise;\n};\nif (plugin.capabilities.includes(\"export\")) await plugin.exportFoo!(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "manifest validation, conformance tests", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Manifest](/records/lexicon/manifest), [Contracts](/records/lexicon/contracts), [Runtime Discovery](/records/architecture/runtime-discovery), [Self-Description](/records/lexicon/self-description), [Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Depends on" }, { "description": "[Implicit Capability](/records/lexicon/implicit-capability)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-capability-declaration", "title": "Capability Declaration" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/architecture-category/metadata-self-description-declarative-systems)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: plugin, module, deployment", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that loads modules or plugins from a validated manifest listing each entry, version and dependency.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Manifest Schema](/records/lexicon/manifest-schema)", "term": "Requires" }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Reinforces" }, { "description": "[Plugin Loading](/records/lexicon/plugin-loading), [Capability Declaration](/records/architecture/capability-declaration)", "term": "Enables" }, { "description": "[Manifest Drift](/records/lexicon/manifest-drift)", "term": "In tension with" }, { "description": "[Hardcoded Registration](/records/lexicon/hardcoded-registration)", "term": "Conflicts with" }, { "description": "[Manifest-Based Design / Manifest Drift](/records/tension/manifest-based-design-manifest-drift)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Implicit Capability](/records/lexicon/implicit-capability), [Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "manifest mismatch, load failure", "term": "Detected by" }, { "description": "manifest validation pass rate", "term": "Measured by" }, { "description": "[Discovery Validation](/records/lexicon/discovery-validation)", "term": "Refactored by" }, { "description": "CI validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "loadPlugin(\"./foo.js\");\nloadPlugin(\"./bar.js\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const manifest = {\n name: \"foo-suite\",\n plugins: [\n { name: \"foo\", entry: \"./foo.js\", version: \"1.0.0\" },\n { name: \"bar\", entry: \"./bar.js\", version: \"1.0.0\" },\n ],\n} as const;\nloadManifest(manifest);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI validation", "term": "Checked by" }, { "description": "Every manifest, schema, configuration file and declared capability, and the code each one describes", "term": "Population" }, { "description": "A verdict stands until the metadata or the code it describes changes", "term": "Freshness" }, { "description": "Manifest or schema validation fails when a declaration and the code disagree", "term": "Refusal" }, { "description": "Each declaration compared with the capability, endpoint or structure found in the code", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "None, because the declaration and the code both declare the capability, so a green comparison shows that they agree and not that either is right", "term": "Authoritative side" }, { "description": "[Manifest Schema](/records/lexicon/manifest-schema), [Self-Describing Architecture](/records/architecture/self-describing-architecture), [Runtime Discovery](/records/architecture/runtime-discovery), [Plugin Loading](/records/lexicon/plugin-loading), [Capability Declaration](/records/architecture/capability-declaration)", "term": "Depends on" }, { "description": "[Hardcoded Registration](/records/lexicon/hardcoded-registration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-manifest-based-design", "title": "Manifest-Based Design" } ], "title": "Metadata / Self-Description / Declarative Systems" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_homoiconicity[\"Homoiconicity\"]\n n_code_as_data[\"Code as Data\"]\n n_metaprogramming[\"Metaprogramming\"]\n n_reflection[\"Reflection\"]\n n_introspection[\"Introspection\"]\n n_compile_time_evaluation[\"Compile-Time Evaluation\"]\n n_runtime_code_generation[\"Runtime Code Generation\"]\n n_domain_specific_language[\"Domain-Specific Language (DSL)\"]\n n_language_oriented_programming[\"Language-Oriented Programming\"]\n n_model_driven_architecture[\"Model-Driven Architecture\"]\n n_homoiconicity --> n_metaprogramming\n n_code_as_data --> n_homoiconicity\n n_reflection --> n_introspection" } ], "icon": "bi-collection", "id": "architecture-category-metaprogramming-language-oriented-architecture", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: language, metaprogramming", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a language represents its programs in its own data structures, so programs can be inspected and transformed as data.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Code-as-Data Representation](/records/lexicon/code-as-data-representation)", "term": "Requires" }, { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Reinforces" }, { "description": "[Macro Systems](/records/lexicon/macro-systems), [DSLs](/records/lexicon/dsls)", "term": "Enables" }, { "description": "[Readability](/records/lexicon/readability)", "term": "In tension with" }, { "description": "[Opaque Syntax Trees](/records/lexicon/opaque-syntax-trees)", "term": "Conflicts with" }, { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" }, { "description": "[Homoiconicity / Readability](/records/tension/homoiconicity-readability)", "term": "Tensions" }, { "description": "[Readability](/records/lexicon/readability): Homoiconicity is programs held as data, while readability is how easily the developer reads the source that results.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[String-Based Code Generation](/records/lexicon/string-based-code-generation)", "term": "Violated by" }, { "description": "language capability check", "term": "Detected by" }, { "description": "macro/code-as-data usage", "term": "Measured by" }, { "description": "[Syntax Tree Generation](/records/lexicon/syntax-tree-generation)", "term": "Refactored by" }, { "description": "language/tooling constraints", "term": "Enforced by" }, { "description": "homoiconicity", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function evaluateFoo(foo: Foo) { return foo.value * 2; }\nconst fooRule = { operation: \"multiply\", operand: 2 };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type Expr =\n | { op: \"value\"; key: keyof Foo }\n | { op: \"const\"; value: number }\n | { op: \"multiply\"; left: Expr; right: Expr };\nconst fooRule: Expr = { op: \"multiply\", left: { op: \"value\", key: \"value\" }, right: { op: \"const\", value: 2 } };\nconst result = evaluate(fooRule, foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "language/tooling constraints", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Code-as-Data Representation](/records/lexicon/code-as-data-representation), [Metaprogramming](/records/architecture/metaprogramming), [Macro Systems](/records/lexicon/macro-systems), [DSLs](/records/lexicon/dsls)", "term": "Depends on" }, { "description": "[Opaque Syntax Trees](/records/lexicon/opaque-syntax-trees)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-homoiconicity", "title": "Homoiconicity" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: language, compiler, runtime", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that logic to be generated or transformed is held as a typed data structure, such as a syntax tree, that tools can inspect and rewrite.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[AST or Data Representation](/records/lexicon/ast-or-data-representation)", "term": "Requires" }, { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Code Generation](/records/lexicon/code-generation)", "term": "Reinforces" }, { "description": "[Program Transformation](/records/lexicon/program-transformation)", "term": "Enables" }, { "description": "[Safety/Debuggability](/records/lexicon/safety-debuggability)", "term": "In tension with" }, { "description": "[String-Based Code Generation](/records/lexicon/string-based-code-generation)", "term": "Conflicts with" }, { "description": "[Code as Data / Safety/Debuggability](/records/tension/code-as-data-safety-debuggability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unchecked Dynamic Code](/records/lexicon/unchecked-dynamic-code)", "term": "Violated by" }, { "description": "dynamic eval/string code construction", "term": "Detected by" }, { "description": "unsafe eval count", "term": "Measured by" }, { "description": "[Syntax Tree Generation](/records/lexicon/syntax-tree-generation), [Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Refactored by" }, { "description": "banned API rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function fooRule(foo: Foo) { return foo.count > 3 && foo.active; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooRule = {\n op: \"and\",\n args: [\n { op: \"gt\", field: \"count\", value: 3 },\n { op: \"eq\", field: \"active\", value: true },\n ],\n} as const;\nexecuteRule(fooRule, foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "banned API rules", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[AST or Data Representation](/records/lexicon/ast-or-data-representation), [Homoiconicity](/records/architecture/homoiconicity), [Code Generation](/records/lexicon/code-generation), [Program Transformation](/records/lexicon/program-transformation)", "term": "Depends on" }, { "description": "[String-Based Code Generation](/records/lexicon/string-based-code-generation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-code-as-data", "title": "Code as Data" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: compile-time, runtime, framework", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing programs that generate or transform other programs, at compile time or at runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Reflection/AST/Code Generation](/records/lexicon/reflection-ast-code-generation)", "term": "Requires" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [DSLs](/records/lexicon/dsls)", "term": "Reinforces" }, { "description": "[Boilerplate Elimination](/records/lexicon/boilerplate-elimination)", "term": "Enables" }, { "description": "[Debuggability](/records/lexicon/debuggability), [Static Analysis](/records/architecture/static-analysis), [Explicit Handwritten Code](/records/lexicon/explicit-handwritten-code)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Referenced by" }, { "description": "[Metaprogramming / Debuggability](/records/tension/debuggability-metaprogramming), [Metaprogramming / Static Analysis](/records/tension/metaprogramming-static-analysis), [Metaprogramming / Explicit Handwritten Code](/records/tension/explicit-handwritten-code-metaprogramming)", "term": "Tensions" }, { "description": "[DSLs](/records/lexicon/dsls): Metaprogramming is code that writes or transforms code, while a domain-specific language is a notation for one domain, which metaprogramming can build.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unchecked Dynamic Code](/records/lexicon/unchecked-dynamic-code)", "term": "Violated by" }, { "description": "dynamic generation without tests/schema", "term": "Detected by" }, { "description": "generated code coverage, [complexity](/records/reasoning/lens-complexity)", "term": "Measured by" }, { "description": "[Unit Tests](/records/lexicon/unit-tests), [Declare Capability](/records/lexicon/declare-capability)", "term": "Refactored by" }, { "description": "generator validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooDto { id!: string; name!: string; }\nclass BarDto { id!: string; name!: string; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const entity = defineEntity({ id: string(), name: string() });\nconst FooDto = generateType(\"FooDto\", entity);\nconst BarDto = generateType(\"BarDto\", entity);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "generator validation", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Reflection/AST/Code Generation](/records/lexicon/reflection-ast-code-generation), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [DSLs](/records/lexicon/dsls), [Boilerplate Elimination](/records/lexicon/boilerplate-elimination)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-metaprogramming", "title": "Metaprogramming" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, metadata, framework", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a program read and act on type metadata about its own structure at runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Runtime Type Metadata](/records/lexicon/runtime-type-metadata)", "term": "Requires" }, { "description": "[Introspection](/records/architecture/introspection), [Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Reinforces" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Enables" }, { "description": "[Performance/Safety](/records/lexicon/performance-safety), [Static Analysis](/records/architecture/static-analysis)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Reflection / Performance/Safety](/records/tension/performance-safety-reflection), [Reflection / Static Analysis](/records/tension/reflection-static-analysis)", "term": "Tensions" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding): Reflection reads type metadata at runtime, while dynamic binding selects an implementation at runtime, with or without reflection.", "term": "Distinct from" }, { "description": "[Introspection](/records/architecture/introspection): Introspection only reads a type and its members, while reflection also acts on what it reads.", "term": "Distinct from" }, { "description": "[Static Analysis](/records/architecture/static-analysis): Reflection inspects structure while the program runs, while static analysis inspects source without running it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Reflective Contract Bypass](/records/lexicon/reflective-contract-bypass)", "term": "Violated by" }, { "description": "reflective access to internals", "term": "Detected by" }, { "description": "unsafe reflection count", "term": "Measured by" }, { "description": "[Declare Capability](/records/lexicon/declare-capability)", "term": "Refactored by" }, { "description": "lint/security rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fields = [\"id\", \"name\", \"count\"];\nfor (const field of fields) renderField(foo[field]);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for (const [field, metadata] of reflect(FooSchema).entries()) {\n renderField(field, metadata, foo[field]);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint/security rules", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Runtime Type Metadata](/records/lexicon/runtime-type-metadata), [Introspection](/records/architecture/introspection), [Runtime Discovery](/records/architecture/runtime-discovery), [Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-reflection", "title": "Reflection" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, metadata", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a program query an object's type and public members at runtime without changing them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Type Metadata](/records/lexicon/type-metadata)", "term": "Requires" }, { "description": "[Self-Describing Systems](/records/lexicon/self-describing-systems)", "term": "Reinforces" }, { "description": "[Discovery](/records/lexicon/discovery), [Diagnostics](/records/lexicon/diagnostics)", "term": "Enables" }, { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "In tension with" }, { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior)", "term": "Conflicts with" }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures), [Reflection](/records/architecture/reflection)", "term": "Referenced by" }, { "description": "[Introspection / Encapsulation](/records/tension/encapsulation-introspection)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exposed Internals](/records/lexicon/exposed-internals)", "term": "Violated by" }, { "description": "introspection of private internals", "term": "Detected by" }, { "description": "introspection usage risk", "term": "Measured by" }, { "description": "[Declare Capability](/records/lexicon/declare-capability)", "term": "Refactored by" }, { "description": "API boundaries", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function supportsExport(plugin: any) {\n try { plugin.exportFoo(foo); return true; } catch { return false; }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function supportsExport(plugin: Plugin) {\n return introspect(plugin).methods.includes(\"exportFoo\");\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API boundaries", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Type Metadata](/records/lexicon/type-metadata), [Self-Describing Systems](/records/lexicon/self-describing-systems), [Discovery](/records/lexicon/discovery), [Diagnostics](/records/lexicon/diagnostics)", "term": "Depends on" }, { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior), [Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-introspection", "title": "Introspection" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: compiler, build", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that computes values, checks or generated code during the build, so the work and its errors happen before runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Compile-Time Inputs](/records/lexicon/compile-time-inputs)", "term": "Requires" }, { "description": "[Optimization](/records/architecture/optimization), [Type Safety](/records/architecture/type-safety)", "term": "Reinforces" }, { "description": "[Early Error Detection](/records/lexicon/early-error-detection)", "term": "Enables" }, { "description": "[Build Complexity](/records/lexicon/build-complexity), [Runtime Dynamic Evaluation](/records/lexicon/runtime-dynamic-evaluation)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Compile-Time Evaluation / Build Complexity](/records/tension/build-complexity-compile-time-evaluation), [Compile-Time Evaluation / Runtime Dynamic Evaluation](/records/tension/compile-time-evaluation-runtime-dynamic-evaluation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Deferred Static Check](/records/lexicon/deferred-static-check)", "term": "Violated by" }, { "description": "repeated runtime reflection/validation", "term": "Detected by" }, { "description": "compile-time coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "compiler plugins/build checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooRoutes = buildRoutesAtStartup(fooRouteDefinitions);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooRoutes = compileTime(() => buildRoutes(fooRouteDefinitions));\nexport const routeTable = fooRoutes;", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compiler plugins/build checks", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Compile-Time Inputs](/records/lexicon/compile-time-inputs), [Optimization](/records/architecture/optimization), [Type Safety](/records/architecture/type-safety), [Early Error Detection](/records/lexicon/early-error-detection)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-compile-time-evaluation", "title": "Compile-Time Evaluation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: runtime, framework", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that builds executable code while the program runs, from a specification such as a field mapping.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Safe Generation Boundary](/records/lexicon/safe-generation-boundary)", "term": "Requires" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Reinforces" }, { "description": "[Dynamic Optimization/Adaptation](/records/lexicon/dynamic-optimization-adaptation)", "term": "Enables" }, { "description": "[Security/Debugging](/records/lexicon/security-debugging), [Static Safety](/records/lexicon/static-safety)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Runtime Code Generation / Security/Debugging](/records/tension/runtime-code-generation-security-debugging), [Runtime Code Generation / Static Safety](/records/tension/runtime-code-generation-static-safety)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unchecked Dynamic Code](/records/lexicon/unchecked-dynamic-code)", "term": "Violated by" }, { "description": "dynamic eval with external input", "term": "Detected by" }, { "description": "unsafe generation paths", "term": "Measured by" }, { "description": "[Syntax Tree Generation](/records/lexicon/syntax-tree-generation), [Sandboxing](/records/lexicon/sandboxing), [Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Refactored by" }, { "description": "[security policy](/records/algorithms/security-policy)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function mapFoo(row: any) {\n return { id: row[\"foo_id\"], name: row[\"foo_name\"], count: row[\"foo_count\"] };\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const mapFoo = generateMapper({\n foo_id: \"id\",\n foo_name: \"name\",\n foo_count: \"count\",\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security policy", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Safe Generation Boundary](/records/lexicon/safe-generation-boundary), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Dynamic Optimization/Adaptation](/records/lexicon/dynamic-optimization-adaptation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-runtime-code-generation", "title": "Runtime Code Generation" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, configuration, rules", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that expresses a domain's rules or workflows in a small language with a defined grammar and a validator.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Formal Grammar/Semantics](/records/lexicon/formal-grammar-semantics)", "term": "Requires" }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Reinforces" }, { "description": "[Domain Expressiveness](/records/lexicon/domain-expressiveness)", "term": "Enables" }, { "description": "[Tooling/Maintenance](/records/lexicon/tooling-maintenance)", "term": "In tension with" }, { "description": "[General-Purpose Boilerplate](/records/lexicon/general-purpose-boilerplate)", "term": "Conflicts with" }, { "description": "[Domain-Specific Language (DSL) / Tooling/Maintenance](/records/tension/domain-specific-language-dsl-tooling-maintenance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Mini-Language](/records/lexicon/ad-hoc-mini-language)", "term": "Violated by" }, { "description": "stringly-typed rules without parser/schema", "term": "Detected by" }, { "description": "DSL validation coverage", "term": "Measured by" }, { "description": "[Validate at the Boundary](/records/lexicon/validate-at-the-boundary)", "term": "Refactored by" }, { "description": "DSL tests, schema/grammar checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "createWorkflow([\n { type: \"validate\", target: \"foo\" },\n { type: \"save\", target: \"foo\" },\n { type: \"publish\", target: \"foo.created\" },\n]);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooWorkflow(\"create\", flow =>\n flow.validate(FooSchema)\n .save(\"FooStore\")\n .publish(\"FooCreated\")\n);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "DSL tests, schema/grammar checks", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Formal Grammar/Semantics](/records/lexicon/formal-grammar-semantics), [Declarative Configuration](/records/architecture/declarative-configuration), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Domain Expressiveness](/records/lexicon/domain-expressiveness)", "term": "Depends on" }, { "description": "[General-Purpose Boilerplate](/records/lexicon/general-purpose-boilerplate)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-domain-specific-language", "title": "Domain-Specific Language (DSL)" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, platform, code generation", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which each problem domain gets its own language, with a type checker and an evaluator, and solutions are written in it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[DSLs](/records/lexicon/dsls), [Code Generation or Interpreters](/records/lexicon/code-generation-or-interpreters)", "term": "Requires" }, { "description": "[Domain Modeling](/records/lexicon/domain-modeling)", "term": "Reinforces" }, { "description": "[High-Level Domain Expression](/records/lexicon/high-level-domain-expression)", "term": "Enables" }, { "description": "[Toolchain Complexity](/records/lexicon/toolchain-complexity), [One-Size General-Purpose Code](/records/lexicon/one-size-general-purpose-code)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Language-Oriented Programming / Toolchain Complexity](/records/tension/language-oriented-programming-toolchain-complexity), [Language-Oriented Programming / One-Size General-Purpose Code](/records/tension/language-oriented-programming-one-size-general-purpose-code)", "term": "Tensions" }, { "description": "[One-Size General-Purpose Code](/records/lexicon/one-size-general-purpose-code): Language-oriented programming gives each domain its own language, while general-purpose code writes every domain in one language.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Mini-Language](/records/lexicon/ad-hoc-mini-language)", "term": "Violated by" }, { "description": "multiple inconsistent rule/config syntaxes", "term": "Detected by" }, { "description": "language consistency/tooling", "term": "Measured by" }, { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language), [Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Refactored by" }, { "description": "grammar/schema validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(config: Record) {\n interpretAdHocConfig(config);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FooPolicyLanguage = defineLanguage({\n expressions: [\"field\", \"equals\", \"all\", \"any\"],\n typeChecker: fooPolicyTypeChecker,\n evaluator: fooPolicyEvaluator,\n});\nFooPolicyLanguage.run(fooPolicy, foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "grammar/schema validation", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[DSLs](/records/lexicon/dsls), [Code Generation or Interpreters](/records/lexicon/code-generation-or-interpreters), [Domain Modeling](/records/lexicon/domain-modeling), [High-Level Domain Expression](/records/lexicon/high-level-domain-expression)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-language-oriented-programming", "title": "Language-Oriented Programming" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/architecture-category/metaprogramming-language-oriented-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, code generation, domain model", "Aliases: MDA", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which a formal model is the source of truth and the implementation is generated from it by transformation rules.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Formal Model](/records/lexicon/formal-model), [Transformation Rules](/records/lexicon/transformation-rules)", "term": "Requires" }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Reinforces" }, { "description": "[Generated Implementations](/records/lexicon/generated-implementations)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Handwritten Divergence](/records/lexicon/handwritten-divergence)", "term": "Conflicts with" }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design): Model-driven architecture generates the implementation from a formal model by transformation rules, while metadata-driven design drives forms, routes or plugins from validated metadata.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Handwritten Divergence](/records/lexicon/handwritten-divergence)", "term": "Violated by" }, { "description": "model-code drift", "term": "Detected by" }, { "description": "generation conformance", "term": "Measured by" }, { "description": "[Code Generation](/records/lexicon/code-generation), [Model Evaluation](/records/architecture/model-evaluation)", "term": "Refactored by" }, { "description": "generation CI", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooController {}\nclass FooService {}\nclass FooRepository {}\nclass FooDto {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooModel = defineModel({\n entity: \"Foo\",\n fields: { id: \"FooId\", name: \"string\" },\n operations: [\"create\", \"read\", \"rename\"],\n});\ngenerateApplication(fooModel);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "generation CI", "term": "Checked by" }, { "description": "Every generator, reflective access, evaluation site and language definition in the codebase", "term": "Population" }, { "description": "A verdict stands until a generator, a grammar or the model it generates from changes", "term": "Freshness" }, { "description": "The banned-API rule, the generator test or the grammar validation fails the change", "term": "Refusal" }, { "description": "Eval and reflection call sites read from source, and generated output compared with its model", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The model and the grammar, which generated output is derived from and compared against", "term": "Authoritative side" }, { "description": "[Formal Model](/records/lexicon/formal-model), [Transformation Rules](/records/lexicon/transformation-rules), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Generated Implementations](/records/lexicon/generated-implementations)", "term": "Depends on" }, { "description": "[Handwritten Divergence](/records/lexicon/handwritten-divergence)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-driven-architecture", "title": "Model-Driven Architecture" } ], "title": "Metaprogramming / Language-Oriented Architecture" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_artificial_intelligence_architecture[\"Artificial Intelligence Architecture\"]\n n_machine_learning_architecture[\"Machine Learning Architecture\"]\n n_model_governance[\"Model Governance\"]\n n_model_evaluation[\"Model Evaluation\"]\n n_model_inference[\"Model Inference\"]\n n_retrieval_augmented_generation[\"Retrieval-Augmented Generation (RAG)\"]\n n_vector_search[\"Vector Search\"]\n n_knowledge_graphs[\"Knowledge Graphs\"]\n n_explainability[\"Explainability\"]\n n_model_safety[\"Model Safety\"]\n n_prompt_engineering[\"Prompt Engineering\"]\n n_model_drift_monitoring[\"Model Drift Monitoring\"]\n n_agentic_architecture[\"Agentic Architecture\"]\n n_artificial_intelligence_architecture --> n_model_governance\n n_artificial_intelligence_architecture --> n_model_evaluation\n n_artificial_intelligence_architecture --> n_model_safety\n n_artificial_intelligence_architecture -.-> n_explainability\n n_machine_learning_architecture --> n_model_governance\n n_model_governance --> n_model_safety\n n_model_evaluation --> n_model_safety\n n_model_inference --> n_artificial_intelligence_architecture\n n_retrieval_augmented_generation --> n_explainability\n n_vector_search --> n_retrieval_augmented_generation\n n_knowledge_graphs --> n_explainability\n n_model_safety --> n_model_governance\n n_prompt_engineering --> n_model_inference\n n_prompt_engineering --> n_model_evaluation\n n_model_drift_monitoring --> n_model_evaluation\n n_model_drift_monitoring --> n_model_governance\n n_agentic_architecture --> n_model_inference\n n_agentic_architecture --> n_explainability\n n_agentic_architecture --> n_model_safety" } ], "icon": "bi-collection", "id": "architecture-category-model-architecture", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: model-backed systems", "Scope: model-backed system, application, platform", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a system that calls a model behind validated inputs, grounded context, schema-checked outputs and governance.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Governance](/records/architecture/model-governance), [Data/Model Boundaries](/records/lexicon/data-model-boundaries)", "term": "Requires" }, { "description": "[Model Evaluation](/records/architecture/model-evaluation), [Model Safety](/records/architecture/model-safety)", "term": "Reinforces" }, { "description": "[Model-Integrated Systems](/records/lexicon/model-integrated-systems)", "term": "Enables" }, { "description": "[Determinism](/records/architecture/determinism), [Explainability](/records/architecture/explainability)", "term": "In tension with" }, { "description": "[Opaque Ungoverned Model Use](/records/lexicon/opaque-ungoverned-model-use)", "term": "Conflicts with" }, { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Referenced by" }, { "description": "[Artificial Intelligence Architecture / Determinism](/records/tension/artificial-intelligence-architecture-determinism), [Artificial Intelligence Architecture / Explainability](/records/tension/artificial-intelligence-architecture-explainability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Ungoverned Model Use](/records/lexicon/opaque-ungoverned-model-use)", "term": "Violated by" }, { "description": "model calls without tests, [logging](/records/architecture/logging), [fallback](/records/lexicon/fallback), [policy](/records/lexicon/policy)", "term": "Detected by" }, { "description": "model quality/safety/evaluation coverage", "term": "Measured by" }, { "description": "[Evaluation Suite](/records/lexicon/evaluation-suite), [Introduce Port](/records/lexicon/introduce-port), [Guardrails](/records/lexicon/guardrails)", "term": "Refactored by" }, { "description": "model governance gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function answerFoo(prompt: string) {\n return model.generate(prompt);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function answerFoo(request: FooRequest) {\n const input = FooRequestSchema.parse(request);\n const context = await fooRetriever.retrieve(input.query);\n const output = await fooModel.generate(buildFooPrompt(input, context));\n return FooResponseSchema.parse(output);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model governance gates", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Governance](/records/architecture/model-governance), [Data/Model Boundaries](/records/lexicon/data-model-boundaries), [Model Evaluation](/records/architecture/model-evaluation), [Model Safety](/records/architecture/model-safety), [Model-Integrated Systems](/records/lexicon/model-integrated-systems)", "term": "Depends on" }, { "description": "[Opaque Ungoverned Model Use](/records/lexicon/opaque-ungoverned-model-use)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-artificial-intelligence-architecture", "title": "Artificial Intelligence Architecture" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: ML pipeline, model serving, data", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a model's lifecycle as versioned data, feature, training, evaluation and serving stages.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Data Pipeline](/records/lexicon/data-pipeline), [Training/Inference Separation](/records/lexicon/training-inference-separation)", "term": "Requires" }, { "description": "[Reproducibility](/records/architecture/reproducibility), [Model Governance](/records/architecture/model-governance)", "term": "Reinforces" }, { "description": "[Reliable Model Lifecycle](/records/lexicon/reliable-model-lifecycle)", "term": "Enables" }, { "description": "[Experimentation Speed](/records/lexicon/experimentation-speed)", "term": "In tension with" }, { "description": "[Ad-Hoc Notebook-to-Production](/records/lexicon/ad-hoc-notebook-to-production)", "term": "Conflicts with" }, { "description": "[Machine Learning Architecture / Experimentation Speed](/records/tension/experimentation-speed-machine-learning-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Violated by" }, { "description": "missing lineage, untracked training inputs", "term": "Detected by" }, { "description": "[reproducibility](/records/architecture/reproducibility), drift, evaluation metrics", "term": "Measured by" }, { "description": "[Data Pipeline](/records/lexicon/data-pipeline), [Prompt Versioning](/records/lexicon/prompt-versioning)", "term": "Refactored by" }, { "description": "MLOps gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const model = trainFoo(loadAllData());\nserve(model);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const dataset = datasetRegistry.load(\"foo\", \"v3\");\nconst features = fooFeaturePipeline.transform(dataset);\nconst model = trainFoo(features, versionedTrainingConfig);\nmodelRegistry.register(model, evaluateFooModel(model, validationSet));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "MLOps gates", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Data Pipeline](/records/lexicon/data-pipeline), [Training/Inference Separation](/records/lexicon/training-inference-separation), [Reproducibility](/records/architecture/reproducibility), [Model Governance](/records/architecture/model-governance), [Reliable Model Lifecycle](/records/lexicon/reliable-model-lifecycle)", "term": "Depends on" }, { "description": "[Ad-Hoc Notebook-to-Production](/records/lexicon/ad-hoc-notebook-to-production)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-machine-learning-architecture", "title": "Machine Learning Architecture" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production models", "Scope: model lifecycle, model-backed system", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of registering, evaluating and approving each model version before it is deployed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Registry](/records/lexicon/model-registry), [Evaluation](/records/lexicon/evaluation), [Approval Policy](/records/lexicon/approval-policy)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Model Safety](/records/architecture/model-safety)", "term": "Reinforces" }, { "description": "[Controlled Model Deployment](/records/lexicon/controlled-model-deployment)", "term": "Enables" }, { "description": "[Experiment Velocity](/records/lexicon/experiment-velocity)", "term": "In tension with" }, { "description": "[Unapproved Model Deployment](/records/lexicon/unapproved-model-deployment), [Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Conflicts with" }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Machine Learning Architecture](/records/architecture/machine-learning-architecture), [Model Safety](/records/architecture/model-safety), [Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" }, { "description": "[Model Governance / Experiment Velocity](/records/tension/experiment-velocity-model-governance)", "term": "Tensions" }, { "description": "[Evaluation](/records/lexicon/evaluation): Model governance registers and approves versions, while evaluation is the assessment it relies on.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unapproved Model Deployment](/records/lexicon/unapproved-model-deployment)", "term": "Violated by" }, { "description": "model without lineage/approval/eval", "term": "Detected by" }, { "description": "governance coverage", "term": "Measured by" }, { "description": "[Registry Pattern](/records/architecture/registry-pattern), [Evaluation Suite](/records/lexicon/evaluation-suite)", "term": "Refactored by" }, { "description": "CI/CD model gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployModel(newestModelFile());", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const candidate = modelRegistry.get(\"foo-model\", \"1.4.0\");\nrequireApproval(candidate, [\"model-owner\", \"risk-owner\"]);\nrequirePolicyCompliance(candidate, fooModelPolicies);\ndeployModel(candidate);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI/CD model gates", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Registry](/records/lexicon/model-registry), [Evaluation](/records/lexicon/evaluation), [Approval Policy](/records/lexicon/approval-policy), [Compliance](/records/architecture/compliance), [Model Safety](/records/architecture/model-safety), [Controlled Model Deployment](/records/lexicon/controlled-model-deployment)", "term": "Depends on" }, { "description": "[Unapproved Model Deployment](/records/lexicon/unapproved-model-deployment), [Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-governance", "title": "Model Governance" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: model, model-backed feature, pipeline", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of measuring a model against datasets, metrics and slices, and comparing the results with acceptance thresholds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Dataset](/records/lexicon/dataset), [Metrics](/records/lexicon/metrics), [Acceptance Criteria](/records/lexicon/acceptance-criteria)", "term": "Requires" }, { "description": "[Model Safety](/records/architecture/model-safety), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Model Selection/Regression Detection](/records/lexicon/model-selection-regression-detection)", "term": "Enables" }, { "description": "[Metric Completeness](/records/lexicon/metric-completeness)", "term": "In tension with" }, { "description": "[Untested Model Deployment](/records/lexicon/untested-model-deployment)", "term": "Conflicts with" }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Prompt Engineering](/records/architecture/prompt-engineering), [Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" }, { "description": "[Model Evaluation / Metric Completeness](/records/tension/metric-completeness-model-evaluation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Untested Model Deployment](/records/lexicon/untested-model-deployment)", "term": "Violated by" }, { "description": "missing eval report/gate", "term": "Detected by" }, { "description": "task metrics, safety metrics, regression rate", "term": "Measured by" }, { "description": "[Evaluation Suite](/records/lexicon/evaluation-suite)", "term": "Refactored by" }, { "description": "model CI gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (model.accuracy > 0.8) deploy(model);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const evaluation = evaluateModel(model, {\n datasets: [fooValidationSet, fooStressSet],\n metrics: [precision, recall, calibration, latencyP95],\n slices: [\"foo-kind\", \"foo-region\"],\n});\nrequireThresholds(evaluation, fooModelThresholds);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model CI gates", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Dataset](/records/lexicon/dataset), [Metrics](/records/lexicon/metrics), [Acceptance Criteria](/records/lexicon/acceptance-criteria), [Model Safety](/records/architecture/model-safety), [Correctness](/records/architecture/correctness), [Model Selection/Regression Detection](/records/lexicon/model-selection-regression-detection)", "term": "Depends on" }, { "description": "[Untested Model Deployment](/records/lexicon/untested-model-deployment)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-evaluation", "title": "Model Evaluation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, model serving", "Aliases: Runtime Prediction/Generation", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to run a trained model on validated input at runtime and return a checked prediction or generation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Artifact](/records/lexicon/model-artifact), [Input/Output Contract](/records/lexicon/input-output-contract)", "term": "Requires" }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "[Latency/Cost](/records/lexicon/latency-cost)", "term": "In tension with" }, { "description": "[Training-Time-Only Model Logic](/records/lexicon/training-time-only-model-logic)", "term": "Conflicts with" }, { "description": "[Prompt Engineering](/records/architecture/prompt-engineering), [Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" }, { "description": "[Model Inference / Latency/Cost](/records/tension/latency-cost-model-inference)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Ungoverned Model Use](/records/lexicon/opaque-ungoverned-model-use)", "term": "Violated by" }, { "description": "raw model calls in business logic", "term": "Detected by" }, { "description": "[latency](/records/architecture/latency), error rate, output quality", "term": "Measured by" }, { "description": "[Extract Module](/records/lexicon/extract-module), [Extract Adapter](/records/lexicon/extract-adapter)", "term": "Refactored by" }, { "description": "serving standards", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const output = model.predict(input as any);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const input = FooInferenceSchema.parse(rawInput);\nconst output = await inferenceRuntime.predict(fooModelVersion, input, {\n timeoutMs: 500,\n traceId,\n});\nreturn FooPredictionSchema.parse(output);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "serving standards", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Artifact](/records/lexicon/model-artifact), [Input/Output Contract](/records/lexicon/input-output-contract), [Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Depends on" }, { "description": "[Training-Time-Only Model Logic](/records/lexicon/training-time-only-model-logic)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-inference", "title": "Model Inference" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: language-model system, knowledge retrieval", "Aliases: RAG", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that retrieves relevant documents for a question and passes them to the model, so the answer can cite its sources.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Retriever](/records/lexicon/retriever), [Document Store](/records/lexicon/document-store), [Grounding Strategy](/records/lexicon/grounding-strategy)", "term": "Requires" }, { "description": "[Explainability](/records/architecture/explainability), [Knowledge Freshness](/records/lexicon/knowledge-freshness)", "term": "Reinforces" }, { "description": "[Contextual Generation](/records/lexicon/contextual-generation)", "term": "Enables" }, { "description": "[Retrieval Quality/Latency](/records/lexicon/retrieval-quality-latency)", "term": "In tension with" }, { "description": "[Ungrounded Generation](/records/lexicon/ungrounded-generation)", "term": "Conflicts with" }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" }, { "description": "[Retrieval-Augmented Generation (RAG) / Retrieval Quality/Latency](/records/tension/retrieval-augmented-generation-rag-retrieval-quality-latency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ungrounded Generation](/records/lexicon/ungrounded-generation)", "term": "Violated by" }, { "description": "missing citations/context in grounded tasks", "term": "Detected by" }, { "description": "retrieval precision/recall, groundedness", "term": "Measured by" }, { "description": "[Retriever](/records/lexicon/retriever), [Evidence Citation](/records/lexicon/evidence-citation)", "term": "Refactored by" }, { "description": "RAG evals", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const answer = await model.generate(`Answer: ${question}`);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const query = normalizeFooQuery(question);\nconst documents = await fooRetriever.search(query, { topK: 8 });\nconst groundedPrompt = buildGroundedFooPrompt(question, documents);\nconst answer = await model.generate(groundedPrompt);\nreturn attachCitations(answer, documents);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "RAG evals", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Retriever](/records/lexicon/retriever), [Document Store](/records/lexicon/document-store), [Grounding Strategy](/records/lexicon/grounding-strategy), [Explainability](/records/architecture/explainability), [Knowledge Freshness](/records/lexicon/knowledge-freshness), [Contextual Generation](/records/lexicon/contextual-generation)", "term": "Depends on" }, { "description": "[Ungrounded Generation](/records/lexicon/ungrounded-generation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-retrieval-augmented-generation", "title": "Retrieval-Augmented Generation (RAG)" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: retrieval, search, RAG", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that finds records whose embeddings lie close to a query's embedding.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Embeddings](/records/lexicon/embeddings), [Vector Index](/records/lexicon/vector-index)", "term": "Requires" }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation), [Semantic Search](/records/lexicon/semantic-search)", "term": "Reinforces" }, { "description": "[Similarity Retrieval](/records/lexicon/similarity-retrieval)", "term": "Enables" }, { "description": "[Explainability/Recall](/records/lexicon/explainability-recall)", "term": "In tension with" }, { "description": "[Exact Keyword Search Only](/records/lexicon/exact-keyword-search-only)", "term": "Conflicts with" }, { "description": "[Vector Search / Explainability/Recall](/records/tension/explainability-recall-vector-search)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exact Keyword Search Only](/records/lexicon/exact-keyword-search-only)", "term": "Violated by" }, { "description": "poor semantic recall", "term": "Detected by" }, { "description": "retrieval metrics, [latency](/records/architecture/latency)", "term": "Measured by" }, { "description": "[Evaluation Suite](/records/lexicon/evaluation-suite)", "term": "Refactored by" }, { "description": "retrieval evaluation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const results = foos.filter(foo => foo.text.includes(query));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const queryVector = await embedder.embed(query);\nconst results = await fooVectorIndex.search(queryVector, {\n topK: 10,\n filter: { tenantId },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "retrieval evaluation", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Embeddings](/records/lexicon/embeddings), [Vector Index](/records/lexicon/vector-index), [Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation), [Semantic Search](/records/lexicon/semantic-search), [Similarity Retrieval](/records/lexicon/similarity-retrieval)", "term": "Depends on" }, { "description": "[Exact Keyword Search Only](/records/lexicon/exact-keyword-search-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-vector-search", "title": "Vector Search" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: knowledge modeling, retrieval, reasoning", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that stores knowledge as typed entities and named relations, validated against a schema, so queries can traverse them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Entities](/records/lexicon/entities), [Relations](/records/lexicon/relations), [Schema/Ontology](/records/lexicon/schema-ontology)", "term": "Requires" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency), [Explainability](/records/architecture/explainability)", "term": "Reinforces" }, { "description": "[Relationship-Aware Retrieval/Reasoning](/records/lexicon/relationship-aware-retrieval-reasoning)", "term": "Enables" }, { "description": "[Curation Cost](/records/lexicon/curation-cost)", "term": "In tension with" }, { "description": "[Flat Document-Only Knowledge](/records/lexicon/flat-document-only-knowledge)", "term": "Conflicts with" }, { "description": "[Knowledge Graphs / Curation Cost](/records/tension/curation-cost-knowledge-graphs)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Flat Document-Only Knowledge](/records/lexicon/flat-document-only-knowledge)", "term": "Violated by" }, { "description": "repeated need for entity relationship traversal", "term": "Detected by" }, { "description": "graph coverage, query accuracy", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "schema/ontology validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooLinks = new Map();\nfooLinks.set(foo.id, [bar.id, baz.id]);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const graph = new KnowledgeGraph();\ngraph.addNode(foo.id, \"Foo\", foo);\ngraph.addNode(bar.id, \"Bar\", bar);\ngraph.addEdge(foo.id, \"DEPENDS_ON\", bar.id);\ngraph.addEdge(bar.id, \"PRODUCES\", baz.id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema/ontology validation", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Entities](/records/lexicon/entities), [Relations](/records/lexicon/relations), [Schema/Ontology](/records/lexicon/schema-ontology), [Semantic Consistency](/records/architecture/semantic-consistency), [Explainability](/records/architecture/explainability), [Relationship-Aware Retrieval/Reasoning](/records/lexicon/relationship-aware-retrieval-reasoning)", "term": "Depends on" }, { "description": "[Flat Document-Only Knowledge](/records/lexicon/flat-document-only-knowledge)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-knowledge-graphs", "title": "Knowledge Graphs" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: regulated domains", "Scope: model, model-backed system, decision flow", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a model's decision comes with the evidence or attribution a reviewer needs to understand it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Traceability](/records/architecture/traceability), [Rationale/Evidence](/records/lexicon/rationale-evidence)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance), [Trust](/records/lexicon/trust)", "term": "Reinforces" }, { "description": "[Audit and Debugging](/records/lexicon/audit-and-debugging)", "term": "Enables" }, { "description": "[Model Complexity](/records/lexicon/model-complexity)", "term": "In tension with" }, { "description": "[Opaque Black-Box Decisions](/records/lexicon/opaque-black-box-decisions)", "term": "Conflicts with" }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation), [Knowledge Graphs](/records/architecture/knowledge-graphs), [Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" }, { "description": "[Explainability / Model Complexity](/records/tension/explainability-model-complexity)", "term": "Tensions" }, { "description": "[Model Safety](/records/architecture/model-safety): Explainability is a decision arriving with its evidence, while model safety is harmful inputs, outputs and actions being prevented.", "term": "Distinct from" }, { "description": "[Traceability](/records/architecture/traceability): Explainability is why one model decision was made, while traceability is following a request or change end to end.", "term": "Distinct from" }, { "description": "[Knowledge Freshness](/records/lexicon/knowledge-freshness): Explainability is showing the evidence behind a decision, while knowledge freshness is that evidence being current.", "term": "Distinct from" }, { "description": "[Model Complexity](/records/lexicon/model-complexity): Explainability is understanding a decision, while model complexity is the intricacy that makes it harder.", "term": "Distinct from" }, { "description": "[Trust](/records/lexicon/trust): Explainability is the evidence a reviewer can inspect, while trust is how far users rely on the outputs.", "term": "Distinct from" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency): Explainability concerns a model's decisions, while semantic consistency concerns names keeping one meaning.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Black-Box Decisions](/records/lexicon/opaque-black-box-decisions)", "term": "Violated by" }, { "description": "missing rationale/feature attribution/citations", "term": "Detected by" }, { "description": "explanation coverage/quality", "term": "Measured by" }, { "description": "[Evidence Citation](/records/lexicon/evidence-citation)", "term": "Refactored by" }, { "description": "model governance gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "return model.predict(foo.features);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const prediction = await model.predict(foo.features);\nconst explanation = await explainer.explain({\n modelVersion: model.version,\n input: foo.features,\n prediction,\n});\nreturn { prediction, explanation };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model governance gates", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Traceability](/records/architecture/traceability), [Rationale/Evidence](/records/lexicon/rationale-evidence), [Governance](/records/architecture/governance), [Trust](/records/lexicon/trust), [Audit and Debugging](/records/lexicon/audit-and-debugging)", "term": "Depends on" }, { "description": "[Opaque Black-Box Decisions](/records/lexicon/opaque-black-box-decisions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-explainability", "title": "Explainability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: model-backed systems", "Scope: model-backed system, model, application", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a model-backed system prevents harmful inputs, outputs and actions through evaluation, guardrails and monitoring.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Evaluation](/records/lexicon/evaluation), [Guardrails](/records/lexicon/guardrails), [Monitoring](/records/architecture/monitoring)", "term": "Requires" }, { "description": "[Model Governance](/records/architecture/model-governance), [Security](/records/lexicon/security)", "term": "Reinforces" }, { "description": "[Safe Model Deployment](/records/lexicon/safe-model-deployment)", "term": "Enables" }, { "description": "[Capability/Utility](/records/lexicon/capability-utility)", "term": "In tension with" }, { "description": "[Unguarded Model Autonomy](/records/lexicon/unguarded-model-autonomy)", "term": "Conflicts with" }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Model Governance](/records/architecture/model-governance), [Model Evaluation](/records/architecture/model-evaluation), [Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" }, { "description": "[Model Safety / Capability/Utility](/records/tension/capability-utility-model-safety)", "term": "Tensions" }, { "description": "[Capability/Utility](/records/lexicon/capability-utility): Model safety is harm being prevented, while capability is the usefulness that strict limits can constrain.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unguarded Model Autonomy](/records/lexicon/unguarded-model-autonomy)", "term": "Violated by" }, { "description": "safety eval failures, missing policy filters", "term": "Detected by" }, { "description": "safety incident rate, eval pass rate", "term": "Measured by" }, { "description": "[Guardrails](/records/lexicon/guardrails), [Code Review](/records/architecture/code-review), [Evaluation Suite](/records/lexicon/evaluation-suite)", "term": "Refactored by" }, { "description": "safety gates, runtime monitors", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "return model.generate(userPrompt);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const input = await safety.validateInput(userPrompt);\nconst draft = await model.generate(input);\nconst checked = await safety.validateOutput(draft, { policy: \"foo-assistant-v2\" });\nif (!checked.allowed) return safeRefusal(checked.reasons);\nreturn checked.output;", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "safety gates, runtime monitors", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Evaluation](/records/lexicon/evaluation), [Guardrails](/records/lexicon/guardrails), [Monitoring](/records/architecture/monitoring), [Model Governance](/records/architecture/model-governance), [Security](/records/lexicon/security), [Safe Model Deployment](/records/lexicon/safe-model-deployment)", "term": "Depends on" }, { "description": "[Unguarded Model Autonomy](/records/lexicon/unguarded-model-autonomy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-safety", "title": "Model Safety" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: model-backed systems", "Scope: model-backed system, language-model system, application", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing model instructions as versioned templates with fixed parameters and an evaluation for each change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Requires" }, { "description": "[Model Evaluation](/records/architecture/model-evaluation), [Reproducibility](/records/architecture/reproducibility)", "term": "Reinforces" }, { "description": "[Structured, Versioned Prompts](/records/lexicon/structured-versioned-prompts)", "term": "Enables" }, { "description": "[Robustness](/records/lexicon/robustness)", "term": "In tension with" }, { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl)", "term": "Conflicts with" }, { "description": "[Prompt Engineering / Robustness](/records/tension/prompt-engineering-robustness)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl)", "term": "Violated by" }, { "description": "scattered prompt string literals", "term": "Detected by" }, { "description": "duplicated prompt count", "term": "Measured by" }, { "description": "[Prompt Registry](/records/lexicon/prompt-registry)", "term": "Refactored by" }, { "description": "model design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const answer = await model.generate(\"summarize: \" + text);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const prompt = fooPromptTemplate.render({ task: \"summarize\", input: text, format: \"bullet-points\", maxWords: 100 });\nconst answer = await model.generate(prompt, { temperature: 0, stop: [\"\\n\\n\"] });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model design review", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Inference](/records/architecture/model-inference), [Model Evaluation](/records/architecture/model-evaluation), [Reproducibility](/records/architecture/reproducibility), [Structured, Versioned Prompts](/records/lexicon/structured-versioned-prompts)", "term": "Depends on" }, { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-prompt-engineering", "title": "Prompt Engineering" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production models", "Scope: model-backed system, model lifecycle, operations", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of tracking a deployed model's inputs and output quality over time and alerting when they move past a threshold.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Requires" }, { "description": "[Observability](/records/architecture/observability), [Model Governance](/records/architecture/model-governance)", "term": "Reinforces" }, { "description": "[Degradation Detection](/records/lexicon/degradation-detection), [Retraining Triggers](/records/lexicon/retraining-triggers)", "term": "Enables" }, { "description": "[Monitoring Cost](/records/lexicon/monitoring-cost)", "term": "In tension with" }, { "description": "[Deploy-and-Forget Models](/records/lexicon/deploy-and-forget-models), [Model Drift](/records/lexicon/model-drift)", "term": "Conflicts with" }, { "description": "[Model Drift Monitoring / Monitoring Cost](/records/tension/model-drift-monitoring-monitoring-cost)", "term": "Tensions" }, { "description": "[Model Evaluation](/records/architecture/model-evaluation): Drift monitoring watches a deployed model over time, while evaluation measures a model against fixed datasets and thresholds.", "term": "Distinct from" }, { "description": "[Model Governance](/records/architecture/model-governance): Drift monitoring runs after deployment, while governance approves each version before it is deployed.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Deploy-and-Forget Models](/records/lexicon/deploy-and-forget-models)", "term": "Violated by" }, { "description": "no ongoing evaluation of live model outputs", "term": "Detected by" }, { "description": "drift in accuracy/quality metrics over time", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "model governance review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "serveModel(fooModel);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "monitor.track(fooModel, {\n metrics: [inputDistribution, predictionConfidence, groundTruthLag],\n alertOn: { populationStabilityIndex: 0.2 },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model governance review", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Evaluation](/records/architecture/model-evaluation), [Observability](/records/architecture/observability), [Model Governance](/records/architecture/model-governance), [Degradation Detection](/records/lexicon/degradation-detection), [Retraining Triggers](/records/lexicon/retraining-triggers)", "term": "Depends on" }, { "description": "[Deploy-and-Forget Models](/records/lexicon/deploy-and-forget-models), [Model Drift](/records/lexicon/model-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-model-drift-monitoring", "title": "Model Drift Monitoring" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Model Architecture](/records/architecture-category/model-architecture)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: regulated domains", "Scope: model-backed system, reasoning, decision flow", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which the model chooses actions from a scoped set of tools, within a step limit and under review.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Model Inference](/records/architecture/model-inference), [Tool Interface](/records/lexicon/tool-interface)", "term": "Requires" }, { "description": "[Explainability](/records/architecture/explainability), [Model Safety](/records/architecture/model-safety)", "term": "Reinforces" }, { "description": "[Bounded Tool-Using Agents](/records/lexicon/bounded-tool-using-agents), [Governed Autonomy](/records/lexicon/governed-autonomy)", "term": "Enables" }, { "description": "[Determinism](/records/architecture/determinism)", "term": "In tension with" }, { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Conflicts with" }, { "description": "[Agentic Architecture / Determinism](/records/tension/agentic-architecture-determinism)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Autonomy](/records/lexicon/unbounded-autonomy)", "term": "Violated by" }, { "description": "agent actions without tool scoping or step limits", "term": "Detected by" }, { "description": "unguarded agent action rate", "term": "Measured by" }, { "description": "[Guardrails](/records/lexicon/guardrails), [Rate Limiting](/records/architecture/rate-limiting), [Code Review](/records/architecture/code-review)", "term": "Refactored by" }, { "description": "model safety review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const answer = await model.generate(question);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const agent = createFooAgent({ tools: [searchFoos, calculator, fooStore], maxSteps: 8 });\nconst answer = await agent.run(question);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "model safety review", "term": "Checked by" }, { "description": "Every model call, model version, prompt, retrieval index and agent tool in a model-backed system", "term": "Population" }, { "description": "A verdict stands for one model version, prompt version and dataset, and goes stale when any of them changes", "term": "Freshness" }, { "description": "The evaluation gate or the governance gate blocks a model, prompt or index that fails its thresholds or lacks approval", "term": "Refusal" }, { "description": "Evaluation reports, registry entries and live output metrics recorded against the model version", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evaluation thresholds and the approval record, which a model, prompt or index is compared against", "term": "Authoritative side" }, { "description": "[Model Inference](/records/architecture/model-inference), [Tool Interface](/records/lexicon/tool-interface), [Explainability](/records/architecture/explainability), [Model Safety](/records/architecture/model-safety), [Bounded Tool-Using Agents](/records/lexicon/bounded-tool-using-agents), [Governed Autonomy](/records/lexicon/governed-autonomy)", "term": "Depends on" }, { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-agentic-architecture", "title": "Agentic Architecture" } ], "title": "Model Architecture" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_observability[\"Observability\"]\n n_logging[\"Logging\"]\n n_monitoring[\"Monitoring\"]\n n_alerting[\"Alerting\"]\n n_auditability[\"Auditability\"]\n n_audit_logging[\"Audit Logging\"]\n n_traceability[\"Traceability\"]\n n_correlation_id[\"Correlation ID\"]\n n_causation_id[\"Causation ID\"]\n n_distributed_tracing[\"Distributed Tracing\"]\n n_slo_sli[\"SLO/SLI\"]\n n_dashboards[\"Dashboards\"]\n n_logging --> n_traceability\n n_alerting --> n_monitoring\n n_auditability --> n_audit_logging\n n_auditability --> n_traceability\n n_audit_logging --> n_auditability\n n_audit_logging --> n_traceability\n n_traceability --> n_correlation_id\n n_traceability --> n_auditability\n n_correlation_id --> n_distributed_tracing\n n_distributed_tracing --> n_observability\n n_slo_sli --> n_monitoring\n n_slo_sli --> n_observability\n n_slo_sli --> n_alerting\n n_dashboards --> n_monitoring\n n_dashboards --> n_observability\n n_dashboards --> n_traceability" } ], "icon": "bi-collection", "id": "architecture-category-observability-auditability-traceability", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production systems", "Scope: service, system, runtime", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system's internal behavior in production can be inferred from the logs, metrics and traces it emits.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Logs](/records/lexicon/logs), [Metrics](/records/lexicon/metrics), [Traces](/records/lexicon/traces)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Debuggability](/records/lexicon/debuggability)", "term": "Reinforces" }, { "description": "[Incident Diagnosis](/records/lexicon/incident-diagnosis)", "term": "Enables" }, { "description": "[Cost/Noise](/records/lexicon/cost-noise)", "term": "In tension with" }, { "description": "[Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Conflicts with" }, { "description": "[Centralized Logging](/records/architecture/centralized-logging), [Information Hiding](/records/architecture/information-hiding), [Dead-Letter Queue](/records/architecture/dead-letter-queue), [Fail Fast](/records/architecture/fail-fast), [Resilience](/records/architecture/resilience), [Error Handling](/records/architecture/error-handling), [Model Drift Monitoring](/records/architecture/model-drift-monitoring), [Distributed Tracing](/records/architecture/distributed-tracing), [SLO/SLI](/records/architecture/slo-sli), [Dashboards](/records/architecture/dashboards), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Canary Deployment](/records/architecture/canary-deployment), [Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Referenced by" }, { "description": "[Observability](/records/algorithms/observability)", "term": "Contracts" }, { "description": "[Observability / Cost/Noise](/records/tension/cost-noise-observability)", "term": "Tensions" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance): Observability is seeing internal behavior, while fault tolerance is operating correctly through component failure.", "term": "Distinct from" }, { "description": "[Auditability](/records/architecture/auditability): Observability infers internal behavior from signals, while auditability ties sensitive actions to their actors afterwards.", "term": "Distinct from" }, { "description": "[Traceability](/records/architecture/traceability): Observability is the whole view from logs, metrics and traces, while traceability is following one request or change end to end.", "term": "Distinct from" }, { "description": "[Cost/Noise](/records/lexicon/cost-noise): Observability is the insight telemetry gives, while cost and noise are what collecting more of it adds.", "term": "Distinct from" }, { "description": "[Debuggability](/records/lexicon/debuggability): Observability is inferring behavior in production, while debuggability is how easily the developer locates a fault.", "term": "Distinct from" }, { "description": "[Fault Isolation](/records/lexicon/fault-isolation): Observability is seeing a failure, while fault isolation is keeping it from spreading.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blind Operation](/records/lexicon/blind-operation)", "term": "Violated by" }, { "description": "missing telemetry around critical paths", "term": "Detected by" }, { "description": "telemetry coverage, MTTR", "term": "Measured by" }, { "description": "[Structured Log](/records/lexicon/structured-log), [Metrics](/records/lexicon/metrics), [Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Refactored by" }, { "description": "observability standards", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function processFoo(foo: Foo) {\n await fooStore.save(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function processFoo(foo: Foo, telemetry: Telemetry) {\n return telemetry.trace(\"foo.process\", { fooId: foo.id }, async span => {\n await fooStore.save(foo);\n span.event(\"foo.saved\");\n telemetry.count(\"foo.processed\", 1);\n });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "observability standards", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Logs](/records/lexicon/logs), [Metrics](/records/lexicon/metrics), [Traces](/records/lexicon/traces), [Resilience](/records/architecture/resilience), [Debuggability](/records/lexicon/debuggability), [Incident Diagnosis](/records/lexicon/incident-diagnosis)", "term": "Depends on" }, { "description": "[Unobservable Failure](/records/architecture/unobservable-failure), [Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-observability", "title": "Observability" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: application, service", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that records structured events with their context as the code runs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Structured Events](/records/lexicon/structured-events), [Context](/records/lexicon/context)", "term": "Requires" }, { "description": "[Traceability](/records/architecture/traceability), [Debugging](/records/lexicon/debugging)", "term": "Reinforces" }, { "description": "[Incident Analysis](/records/lexicon/incident-analysis)", "term": "Enables" }, { "description": "[Noise/Personal Data Leakage](/records/lexicon/noise-personal-data-leakage)", "term": "In tension with" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Log-as-Control-Flow](/records/architecture/log-as-control-flow)", "term": "Conflicts with" }, { "description": "[Logging / Noise/Personal Data Leakage](/records/tension/logging-noise-personal-data-leakage)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Violated by" }, { "description": "absence of logs on error/business events", "term": "Detected by" }, { "description": "log coverage, signal/noise ratio", "term": "Measured by" }, { "description": "[Structured Log](/records/lexicon/structured-log), [Pass Context Explicitly](/records/lexicon/pass-context-explicitly)", "term": "Refactored by" }, { "description": "logging policy, linting", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "console.log(\"saved\", foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "logger.info(\"foo.saved\", { fooId: foo.id, version: foo.version });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "logging policy, linting", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Structured Events](/records/lexicon/structured-events), [Context](/records/lexicon/context), [Traceability](/records/architecture/traceability), [Debugging](/records/lexicon/debugging), [Incident Analysis](/records/lexicon/incident-analysis)", "term": "Depends on" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Log-as-Control-Flow](/records/architecture/log-as-control-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-logging", "title": "Logging" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: service, infrastructure", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that collects metrics about resources and service levels over time and compares them with thresholds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Metrics](/records/lexicon/metrics), [Thresholds](/records/lexicon/thresholds)", "term": "Requires" }, { "description": "[Reliability](/records/lexicon/reliability)", "term": "Reinforces" }, { "description": "[Failure Detection](/records/lexicon/failure-detection)", "term": "Enables" }, { "description": "[Alert Noise](/records/lexicon/alert-noise)", "term": "In tension with" }, { "description": "[Blind Operation](/records/lexicon/blind-operation)", "term": "Conflicts with" }, { "description": "[Model Safety](/records/architecture/model-safety), [Alerting](/records/architecture/alerting), [SLO/SLI](/records/architecture/slo-sli), [Dashboards](/records/architecture/dashboards), [Resource Utilization](/records/architecture/resource-utilization)", "term": "Referenced by" }, { "description": "[Monitoring / Alert Noise](/records/tension/alert-noise-monitoring)", "term": "Tensions" }, { "description": "[Alerting](/records/architecture/alerting): Monitoring collects and compares metrics over time, while alerting notifies a responder when a condition holds past its threshold.", "term": "Distinct from" }, { "description": "[Metrics](/records/lexicon/metrics): Monitoring is the mechanism that collects and compares, while metrics are the measurements it collects.", "term": "Distinct from" }, { "description": "[Guardrails](/records/lexicon/guardrails): Monitoring observes behavior after the fact, while guardrails bound what a model may output or do as it runs.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blind Operation](/records/lexicon/blind-operation)", "term": "Violated by" }, { "description": "missing dashboards/SLI metrics", "term": "Detected by" }, { "description": "metric coverage, detection latency", "term": "Measured by" }, { "description": "[Metrics](/records/lexicon/metrics), [Service Level Objectives](/records/lexicon/service-level-objectives)", "term": "Refactored by" }, { "description": "production readiness checklist", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "setInterval(() => report(fooQueue.length), 60_000);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "metrics.gauge(\"foo.queue.depth\", () => fooQueue.length);\nmetrics.histogram(\"foo.processing.duration_ms\", fooProcessingDuration);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "production readiness checklist", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Metrics](/records/lexicon/metrics), [Thresholds](/records/lexicon/thresholds), [Reliability](/records/lexicon/reliability), [Failure Detection](/records/lexicon/failure-detection)", "term": "Depends on" }, { "description": "[Blind Operation](/records/lexicon/blind-operation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-monitoring", "title": "Monitoring" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: operations, service", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that notifies an on-call responder when a monitored condition holds for longer than its threshold.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring), [Thresholds](/records/lexicon/thresholds)", "term": "Requires" }, { "description": "[Incident Response](/records/lexicon/incident-response)", "term": "Reinforces" }, { "description": "[Timely Intervention](/records/lexicon/timely-intervention)", "term": "Enables" }, { "description": "[Alert Fatigue](/records/lexicon/alert-fatigue)", "term": "In tension with" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Observability Noise](/records/architecture/observability-noise)", "term": "Conflicts with" }, { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Referenced by" }, { "description": "[Alerting / Alert Fatigue](/records/tension/alert-fatigue-alerting)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Violated by" }, { "description": "incident reported by customers before monitoring caught it", "term": "Detected by" }, { "description": "MTTD, alert precision", "term": "Measured by" }, { "description": "[Alert on Critical Failure](/records/lexicon/alert-on-critical-failure), [Track Rule Metrics](/records/lexicon/track-rule-metrics)", "term": "Refactored by" }, { "description": "on-call policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (errorRate > 0.05) notify(\"foo errors\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "alerts.define(\"FooErrorBudgetBurn\", {\n condition: rate(\"foo.errors\", \"5m\") > 0.05,\n for: \"10m\",\n severity: \"critical\",\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "on-call policy", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Monitoring](/records/architecture/monitoring), [Thresholds](/records/lexicon/thresholds), [Incident Response](/records/lexicon/incident-response), [Timely Intervention](/records/lexicon/timely-intervention)", "term": "Depends on" }, { "description": "[Silent Failure](/records/lexicon/silent-failure), [Observability Noise](/records/architecture/observability-noise)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-alerting", "title": "Alerting" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: regulated or sensitive systems", "Scope: system, data, security", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which each sensitive action can be traced afterwards to its actor, target, time and reason.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging), [Traceability](/records/architecture/traceability)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance)", "term": "Reinforces" }, { "description": "[Accountability](/records/lexicon/accountability)", "term": "Enables" }, { "description": "[Storage/Privacy](/records/lexicon/storage-privacy)", "term": "In tension with" }, { "description": "[Opaque Mutation](/records/lexicon/opaque-mutation)", "term": "Conflicts with" }, { "description": "[Centralized Logging](/records/architecture/centralized-logging), [Reproducibility](/records/architecture/reproducibility), [Event Sourcing](/records/architecture/event-sourcing), [Append-Only Log](/records/architecture/append-only-log), [Audit Logging](/records/architecture/audit-logging), [Traceability](/records/architecture/traceability), [Compliance](/records/architecture/compliance), [Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Contracts" }, { "description": "[Auditability / Storage/Privacy](/records/tension/auditability-storage-privacy)", "term": "Tensions" }, { "description": "[Traceability](/records/architecture/traceability): Auditability ties each sensitive action to its actor, target, time and reason, while traceability follows a request or change end to end.", "term": "Distinct from" }, { "description": "[Storage/Privacy](/records/lexicon/storage-privacy): Auditability is keeping the history, while storage and privacy are the costs of keeping it.", "term": "Distinct from" }, { "description": "[Reproducibility](/records/architecture/reproducibility): Auditability records what happened, while reproducibility reruns it and gets the same output.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Untracked Mutation](/records/lexicon/untracked-mutation)", "term": "Violated by" }, { "description": "missing audit event for sensitive operation", "term": "Detected by" }, { "description": "audit event coverage", "term": "Measured by" }, { "description": "[Audit Logging](/records/architecture/audit-logging), [Data Change Audit](/records/lexicon/data-change-audit)", "term": "Refactored by" }, { "description": "compliance gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renameFoo(foo: Foo, name: string) { foo.name = name; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function renameFoo(foo: Foo, name: string, actor: Actor) {\n const previous = foo.name;\n foo.rename(name);\n audit.append({ action: \"FooRenamed\", fooId: foo.id, actorId: actor.id, previous, next: name });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compliance gates", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Audit Logging](/records/architecture/audit-logging), [Traceability](/records/architecture/traceability), [Compliance](/records/architecture/compliance), [Accountability](/records/lexicon/accountability)", "term": "Depends on" }, { "description": "[Opaque Mutation](/records/lexicon/opaque-mutation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-auditability", "title": "Auditability" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: sensitive systems", "Scope: security, compliance, data mutation", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that appends an immutable record of each sensitive operation, naming the actor, the action, the target and the time.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Actor](/records/lexicon/actor), [Action](/records/lexicon/action), [Timestamp](/records/lexicon/timestamp), [Target](/records/lexicon/target)", "term": "Requires" }, { "description": "[Auditability](/records/architecture/auditability), [Traceability](/records/architecture/traceability)", "term": "Reinforces" }, { "description": "[Forensics](/records/lexicon/forensics)", "term": "Enables" }, { "description": "[Privacy](/records/lexicon/privacy)", "term": "In tension with" }, { "description": "[Untracked Mutation](/records/lexicon/untracked-mutation)", "term": "Conflicts with" }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Referenced by" }, { "description": "[Audit Logging / Privacy](/records/tension/audit-logging-privacy)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Mutation](/records/lexicon/opaque-mutation)", "term": "Violated by" }, { "description": "missing audit instrumentation", "term": "Detected by" }, { "description": "audit coverage", "term": "Measured by" }, { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Refactored by" }, { "description": "[policy-as-code](/records/architecture/policy-as-code), [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "logger.info(`user ${user.id} changed foo ${foo.id}`);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "auditLog.append({\n eventId: eventId(),\n action: \"FOO_UPDATE\",\n actorId: user.id,\n resourceId: foo.id,\n occurredAt: clock.now().toISOString(),\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy-as-code, tests", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Actor](/records/lexicon/actor), [Action](/records/lexicon/action), [Timestamp](/records/lexicon/timestamp), [Target](/records/lexicon/target), [Auditability](/records/architecture/auditability), [Traceability](/records/architecture/traceability), [Forensics](/records/lexicon/forensics)", "term": "Depends on" }, { "description": "[Untracked Mutation](/records/lexicon/untracked-mutation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-audit-logging", "title": "Audit Logging" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: request, workflow, change", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a request, workflow or change can be followed end to end through correlated records.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Correlation ID](/records/architecture/correlation-id), [Logs/Traces](/records/lexicon/logs-traces)", "term": "Requires" }, { "description": "[Debuggability](/records/lexicon/debuggability), [Auditability](/records/architecture/auditability)", "term": "Reinforces" }, { "description": "[End-to-End Causality](/records/lexicon/end-to-end-causality)", "term": "Enables" }, { "description": "[Metadata Propagation Overhead](/records/lexicon/metadata-propagation-overhead)", "term": "In tension with" }, { "description": "[Anonymous Flow](/records/lexicon/anonymous-flow)", "term": "Conflicts with" }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Causality](/records/architecture/causality), [Causal Dependency](/records/architecture/causal-dependency), [Choreography](/records/architecture/choreography), [Polymorphism](/records/architecture/polymorphism), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Explainability](/records/architecture/explainability), [Logging](/records/architecture/logging), [Auditability](/records/architecture/auditability), [Audit Logging](/records/architecture/audit-logging), [Dashboards](/records/architecture/dashboards), [Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern), [Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Referenced by" }, { "description": "[Traceability / Metadata Propagation Overhead](/records/tension/metadata-propagation-overhead-traceability)", "term": "Tensions" }, { "description": "[Metadata Propagation Overhead](/records/lexicon/metadata-propagation-overhead): Traceability is following a request end to end, while propagation overhead is the size and processing that carrying its metadata costs.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Uncorrelated Events](/records/lexicon/uncorrelated-events)", "term": "Violated by" }, { "description": "missing correlation propagation", "term": "Detected by" }, { "description": "trace completeness", "term": "Measured by" }, { "description": "[Correlation ID](/records/architecture/correlation-id), [Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Refactored by" }, { "description": "middleware, tracing policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await processFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const trace = traceContext.start({ operation: \"processFoo\", fooId: foo.id });\nawait processFoo(foo, trace);\ntrace.finish();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "middleware, tracing policy", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Correlation ID](/records/architecture/correlation-id), [Logs/Traces](/records/lexicon/logs-traces), [Debuggability](/records/lexicon/debuggability), [Auditability](/records/architecture/auditability), [End-to-End Causality](/records/lexicon/end-to-end-causality)", "term": "Depends on" }, { "description": "[Anonymous Flow](/records/lexicon/anonymous-flow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-traceability", "title": "Traceability" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: request, message, workflow", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that attaches one identifier to a request and carries it through every call, message and log line the request causes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Context Propagation](/records/lexicon/context-propagation)", "term": "Requires" }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Reinforces" }, { "description": "[Request-Level Traceability](/records/lexicon/request-level-traceability)", "term": "Enables" }, { "description": "[Header/Metadata Management](/records/lexicon/header-metadata-management)", "term": "In tension with" }, { "description": "[Uncorrelated Events](/records/lexicon/uncorrelated-events)", "term": "Conflicts with" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "Referenced by" }, { "description": "[Correlation ID / Header/Metadata Management](/records/tension/correlation-id-header-metadata-management)", "term": "Tensions" }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing): A correlation id is one identifier carried through a request, while distributed tracing records each call as a timed span of one trace.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Uncorrelated Events](/records/lexicon/uncorrelated-events)", "term": "Violated by" }, { "description": "missing correlation field", "term": "Detected by" }, { "description": "correlation coverage", "term": "Measured by" }, { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Refactored by" }, { "description": "logging/tracing standards", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await http.post(\"/bar\", { fooId: foo.id });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const correlationId = request.headers.get(\"X-Correlation-ID\") ?? idSource.next();\nawait http.post(\"/bar\", { fooId: foo.id }, { headers: { \"X-Correlation-ID\": correlationId } });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "logging/tracing standards", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Context Propagation](/records/lexicon/context-propagation), [Distributed Tracing](/records/architecture/distributed-tracing), [Request-Level Traceability](/records/lexicon/request-level-traceability)", "term": "Depends on" }, { "description": "[Uncorrelated Events](/records/lexicon/uncorrelated-events)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-correlation-id", "title": "Correlation ID" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: event, message, workflow", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that stamps each event with the identifier of the event that caused it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Event Metadata](/records/lexicon/event-metadata)", "term": "Requires" }, { "description": "[Causality](/records/architecture/causality), [Audit Trail](/records/lexicon/audit-trail)", "term": "Reinforces" }, { "description": "[Cause-Effect Reconstruction](/records/lexicon/cause-effect-reconstruction)", "term": "Enables" }, { "description": "[Metadata Verbosity](/records/lexicon/metadata-verbosity)", "term": "In tension with" }, { "description": "[Unlinked Events](/records/lexicon/unlinked-events)", "term": "Conflicts with" }, { "description": "[Causation ID / Metadata Verbosity](/records/tension/causation-id-metadata-verbosity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unlinked Events](/records/lexicon/unlinked-events)", "term": "Violated by" }, { "description": "missing causation field in event metadata", "term": "Detected by" }, { "description": "causation coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "event schema rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "events.publish({ id: eventId(), type: \"BarCreated\", fooId: event.fooId });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "events.publish({\n id: eventId(),\n type: \"BarCreated\",\n fooId: event.fooId,\n correlationId: event.correlationId,\n causationId: event.id,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "event schema rules", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Event Metadata](/records/lexicon/event-metadata), [Causality](/records/architecture/causality), [Audit Trail](/records/lexicon/audit-trail), [Cause-Effect Reconstruction](/records/lexicon/cause-effect-reconstruction)", "term": "Depends on" }, { "description": "[Unlinked Events](/records/lexicon/unlinked-events)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-causation-id", "title": "Causation ID" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: distributed systems", "Scope: distributed system, service mesh", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that propagates a trace context across service calls and records each call as a timed span of one trace.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Trace Context Propagation](/records/lexicon/trace-context-propagation)", "term": "Requires" }, { "description": "[Observability](/records/architecture/observability), [Causality](/records/architecture/causality)", "term": "Reinforces" }, { "description": "[Latency/Failure Root Cause Analysis](/records/lexicon/latency-failure-root-cause-analysis)", "term": "Enables" }, { "description": "[Overhead/Sampling](/records/lexicon/overhead-sampling)", "term": "In tension with" }, { "description": "[Opaque Distributed Calls](/records/lexicon/opaque-distributed-calls)", "term": "Conflicts with" }, { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Referenced by" }, { "description": "[Distributed Tracing / Overhead/Sampling](/records/tension/distributed-tracing-overhead-sampling)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Opaque Distributed Calls](/records/lexicon/opaque-distributed-calls)", "term": "Violated by" }, { "description": "broken traces, missing spans", "term": "Detected by" }, { "description": "trace completeness, span coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "observability policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooService.call();\nawait barService.call();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await tracer.span(\"foo.request\", async span => {\n await fooService.call({ traceparent: span.traceparent });\n await barService.call({ traceparent: span.traceparent });\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "observability policy", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Trace Context Propagation](/records/lexicon/trace-context-propagation), [Observability](/records/architecture/observability), [Causality](/records/architecture/causality), [Latency/Failure Root Cause Analysis](/records/lexicon/latency-failure-root-cause-analysis)", "term": "Depends on" }, { "description": "[Opaque Distributed Calls](/records/lexicon/opaque-distributed-calls)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-distributed-tracing", "title": "Distributed Tracing" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production systems", "Scope: service, reliability, operations", "Aliases: Service Level Objective, Service Level Indicator, Objective Reliability Targets", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a service's reliability is stated as a measured indicator with an objective and an error budget over a window.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Requires" }, { "description": "[Observability](/records/architecture/observability), [Alerting](/records/architecture/alerting)", "term": "Reinforces" }, { "description": "[Error-Budget Decisions](/records/lexicon/error-budget-decisions)", "term": "Enables" }, { "description": "[Feature Velocity](/records/lexicon/feature-velocity)", "term": "In tension with" }, { "description": "[Vague Reliability Goals](/records/lexicon/vague-reliability-goals)", "term": "Conflicts with" }, { "description": "[SLO/SLI / Feature Velocity](/records/tension/feature-velocity-slo-sli)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Vague Reliability Goals](/records/lexicon/vague-reliability-goals)", "term": "Violated by" }, { "description": "no measured indicator behind reliability claims", "term": "Detected by" }, { "description": "SLO attainment vs error budget", "term": "Measured by" }, { "description": "[Service Level Objectives](/records/lexicon/service-level-objectives)", "term": "Refactored by" }, { "description": "reliability review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "alert.when(latency > 1000);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooLatencySli = ratio(\"foo.requests.fast\", \"foo.requests.total\");\ndefineSLO(\"foo-latency\", { sli: fooLatencySli, objective: 0.99, window: \"30d\", errorBudget: 0.01 });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "reliability review", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Monitoring](/records/architecture/monitoring), [Observability](/records/architecture/observability), [Alerting](/records/architecture/alerting), [Error-Budget Decisions](/records/lexicon/error-budget-decisions)", "term": "Depends on" }, { "description": "[Vague Reliability Goals](/records/lexicon/vague-reliability-goals)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-slo-sli", "title": "SLO/SLI" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/architecture-category/observability-auditability-traceability)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: service, operations, visibility", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about a system's key signals, arranged as panels that show health and trends at a glance.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Requires" }, { "description": "[Observability](/records/architecture/observability), [Traceability](/records/architecture/traceability)", "term": "Reinforces" }, { "description": "[At-a-Glance System Health](/records/lexicon/at-a-glance-system-health), [Trend Visibility](/records/lexicon/trend-visibility)", "term": "Enables" }, { "description": "[Dashboard Sprawl](/records/lexicon/dashboard-sprawl)", "term": "In tension with" }, { "description": "[Log-Grep-Only Diagnosis](/records/lexicon/log-grep-only-diagnosis)", "term": "Conflicts with" }, { "description": "[Dashboards / Dashboard Sprawl](/records/tension/dashboard-sprawl-dashboards)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Log-Grep-Only Diagnosis](/records/lexicon/log-grep-only-diagnosis)", "term": "Violated by" }, { "description": "no curated view of key signals", "term": "Detected by" }, { "description": "time-to-diagnose during incidents", "term": "Measured by" }, { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Refactored by" }, { "description": "operations review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "grepLogsForFooErrors();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooDashboard = dashboard(\"foo-health\", {\n panels: [rate(\"foo.errors\"), histogram(\"foo.latency\"), gauge(\"foo.queue.depth\")],\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "operations review", "term": "Checked by" }, { "description": "Every critical path, sensitive operation, request and message the telemetry is meant to cover", "term": "Population" }, { "description": "A verdict stands until a code path, a telemetry field or an alert threshold changes", "term": "Freshness" }, { "description": "The logging, tracing or audit policy check fails a change that leaves a covered path without its signal", "term": "Refusal" }, { "description": "Emitted logs, metrics, spans and audit records, compared with the paths that should emit them", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared telemetry coverage, which the emitted signals are compared against", "term": "Authoritative side" }, { "description": "[Monitoring](/records/architecture/monitoring), [Observability](/records/architecture/observability), [Traceability](/records/architecture/traceability), [At-a-Glance System Health](/records/lexicon/at-a-glance-system-health), [Trend Visibility](/records/lexicon/trend-visibility)", "term": "Depends on" }, { "description": "[Log-Grep-Only Diagnosis](/records/lexicon/log-grep-only-diagnosis)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dashboards", "title": "Dashboards" } ], "title": "Observability / Auditability / Traceability" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_strategy_pattern[\"Strategy Pattern\"]\n n_template_method_pattern[\"Template Method Pattern\"]\n n_observer_pattern[\"Observer Pattern\"]\n n_mediator_pattern[\"Mediator Pattern\"]\n n_command_pattern[\"Command Pattern\"]\n n_state_pattern[\"State Pattern\"]\n n_chain_of_responsibility_pattern[\"Chain of Responsibility Pattern\"]\n n_iterator_pattern[\"Iterator Pattern\"]\n n_visitor_pattern[\"Visitor Pattern\"]\n n_memento_pattern[\"Memento Pattern\"]\n n_null_object_pattern[\"Null Object Pattern\"]\n n_finite_state_machine[\"Finite State Machine\"]\n n_statecharts[\"Statecharts\"]\n n_finite_state_machine --> n_state_pattern\n n_statecharts --> n_finite_state_machine\n n_statecharts --> n_finite_state_machine" } ], "icon": "bi-collection", "id": "architecture-category-behavioral-patterns", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: algorithm, policy, behavior", "Aliases: Policy Pattern", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that puts each interchangeable algorithm behind one interface, so the caller selects behavior by passing an object.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Interchangeable Algorithms](/records/lexicon/interchangeable-algorithms)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism)", "term": "Reinforces" }, { "description": "[Runtime Behavior Selection](/records/lexicon/runtime-behavior-selection)", "term": "Enables" }, { "description": "[Class Count](/records/lexicon/class-count)", "term": "In tension with" }, { "description": "[Large Conditional Logic](/records/lexicon/large-conditional-logic)", "term": "Conflicts with" }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism)", "term": "Referenced by" }, { "description": "[Strategy Pattern / Class Count](/records/tension/class-count-strategy-pattern)", "term": "Tensions" }, { "description": "[Decorator Pattern](/records/architecture/decorator-pattern): A strategy replaces behavior behind one interface, while a decorator adds behavior by wrapping an object in the same interface.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Large Conditional Logic](/records/lexicon/large-conditional-logic)", "term": "Violated by" }, { "description": "conditional strategy selection with duplicated behavior", "term": "Detected by" }, { "description": "conditional complexity", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "complexity thresholds, [review](/records/lexicon/review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function priceFoo(kind: string, value: number) {\n if (kind === \"standard\") return value;\n if (kind === \"double\") return value * 2;\n return 0;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooPricing { price(value: number): number; }\nconst standard: FooPricing = { price: value => value };\nconst doubled: FooPricing = { price: value => value * 2 };\nfunction priceFoo(strategy: FooPricing, value: number) { return strategy.price(value); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "complexity thresholds, review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Interchangeable Algorithms](/records/lexicon/interchangeable-algorithms), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism), [Runtime Behavior Selection](/records/lexicon/runtime-behavior-selection)", "term": "Depends on" }, { "description": "[Large Conditional Logic](/records/lexicon/large-conditional-logic)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-strategy-pattern", "title": "Strategy Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: workflow, framework", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that fixes the steps of an algorithm in a base class and lets subclasses supply the steps that vary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Algorithm Skeleton](/records/lexicon/stable-algorithm-skeleton)", "term": "Requires" }, { "description": "[Framework Reuse](/records/lexicon/framework-reuse)", "term": "Reinforces" }, { "description": "[Controlled Variation](/records/lexicon/controlled-variation)", "term": "Enables" }, { "description": "[Inheritance Coupling](/records/lexicon/inheritance-coupling)", "term": "In tension with" }, { "description": "[Duplicated Workflow](/records/lexicon/duplicated-workflow)", "term": "Conflicts with" }, { "description": "[Template Method Pattern / Inheritance Coupling](/records/tension/inheritance-coupling-template-method-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Duplicated Workflow](/records/lexicon/duplicated-workflow)", "term": "Violated by" }, { "description": "duplicated method sequences", "term": "Detected by" }, { "description": "workflow duplication", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function importJsonFoo(raw: string) { validateJson(raw); return saveFoo(parseJson(raw)); }\nfunction importCsvFoo(raw: string) { validateCsv(raw); return saveFoo(parseCsv(raw)); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "abstract class FooImporter {\n import(raw: string) { this.validate(raw); return saveFoo(this.parse(raw)); }\n protected abstract validate(raw: string): void;\n protected abstract parse(raw: string): Foo;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Stable Algorithm Skeleton](/records/lexicon/stable-algorithm-skeleton), [Framework Reuse](/records/lexicon/framework-reuse), [Controlled Variation](/records/lexicon/controlled-variation)", "term": "Depends on" }, { "description": "[Duplicated Workflow](/records/lexicon/duplicated-workflow)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-template-method-pattern", "title": "Template Method Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: event notification, runtime", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which a subject publishes events to subscribers it does not know by name.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Subject/Subscriber Contract](/records/lexicon/subject-subscriber-contract)", "term": "Requires" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Reinforces" }, { "description": "[Decoupled Notification](/records/lexicon/decoupled-notification)", "term": "Enables" }, { "description": "[Ordering](/records/lexicon/ordering), [Debuggability](/records/lexicon/debuggability)", "term": "In tension with" }, { "description": "[Direct Callback Coupling](/records/lexicon/direct-callback-coupling)", "term": "Conflicts with" }, { "description": "[Observer Pattern / Ordering](/records/tension/observer-pattern-ordering), [Observer Pattern / Debuggability](/records/tension/debuggability-observer-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct Callback Coupling](/records/lexicon/direct-callback-coupling)", "term": "Violated by" }, { "description": "direct calls to multiple listeners", "term": "Detected by" }, { "description": "subscriber coupling count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "event contract tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooEditor {\n save(foo: Foo) {\n fooStore.save(foo);\n refreshFooView(foo);\n sendFooEmail(foo);\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooEvents {\n #listeners = new Set<(event: FooEvent) => void>();\n subscribe(listener: (event: FooEvent) => void) { this.#listeners.add(listener); }\n publish(event: FooEvent) { this.#listeners.forEach(listener => listener(event)); }\n}\nclass FooEditor {\n constructor(private readonly events: FooEvents) {}\n save(foo: Foo) {\n fooStore.save(foo);\n this.events.publish({ type: \"FooSaved\", foo });\n }\n}\nfooEvents.subscribe(event => refreshFooView(event.foo));\nfooEvents.subscribe(event => sendFooEmail(event.foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "event contract tests", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Subject/Subscriber Contract](/records/lexicon/subject-subscriber-contract), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Decoupled Notification](/records/lexicon/decoupled-notification)", "term": "Depends on" }, { "description": "[Direct Callback Coupling](/records/lexicon/direct-callback-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-observer-pattern", "title": "Observer Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: object coordination, module", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that routes the interactions between a set of objects through one coordinating object.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Complexity](/records/lexicon/coordination-complexity)", "term": "Requires" }, { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Centralized Interaction Logic](/records/lexicon/centralized-interaction-logic)", "term": "Enables" }, { "description": "[Mediator God Object](/records/lexicon/mediator-god-object)", "term": "In tension with" }, { "description": "[Mesh Dependencies](/records/lexicon/mesh-dependencies)", "term": "Conflicts with" }, { "description": "[Mediator Pattern / Mediator God Object](/records/tension/mediator-god-object-mediator-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Mesh Dependencies](/records/lexicon/mesh-dependencies)", "term": "Violated by" }, { "description": "dense object dependency graph", "term": "Detected by" }, { "description": "interaction graph density", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "dependency graph checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooEditor.notify(fooList, fooDetails, fooToolbar, foo);\nfooList.update(fooDetails, fooToolbar, foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooMediator {\n constructor(private readonly list: FooList, private readonly details: FooDetails) {}\n handle(event: FooEvent) {\n this.list.apply(event);\n this.details.apply(event);\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency graph checks", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Coordination Complexity](/records/lexicon/coordination-complexity), [Low Coupling](/records/architecture/low-coupling), [Centralized Interaction Logic](/records/lexicon/centralized-interaction-logic)", "term": "Depends on" }, { "description": "[Mesh Dependencies](/records/lexicon/mesh-dependencies)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-mediator-pattern", "title": "Mediator Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: behavior, invocation, workflow", "Aliases: Action Pattern", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that wraps a request in an object, so it can be queued, deferred or undone.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility)", "term": "Reinforces" }, { "description": "[Undo/Redo](/records/lexicon/undo-redo), [Deferred Execution](/records/lexicon/deferred-execution), [Deferred Execution](/records/lexicon/deferred-execution)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Direct Method Invocation](/records/lexicon/direct-method-invocation)", "term": "Conflicts with" }, { "description": "[Command Pattern / Simplicity](/records/tension/command-pattern-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct Method Invocation](/records/lexicon/direct-method-invocation)", "term": "Violated by" }, { "description": "switch/if chains selecting an operation to run", "term": "Detected by" }, { "description": "dispatch-branch count per action site", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "button.onClick = () => fooEditor.delete(foo.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooCommand { execute(): void; undo(): void; }\nclass DeleteFooCommand implements FooCommand {\n constructor(private readonly id: FooId) {}\n execute() { fooStore.delete(this.id); }\n undo() { fooStore.restore(this.id); }\n}\nhistory.run(new DeleteFooCommand(foo.id));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Undo/Redo](/records/lexicon/undo-redo), [Deferred Execution](/records/lexicon/deferred-execution), [Deferred Execution](/records/lexicon/deferred-execution)", "term": "Depends on" }, { "description": "[Direct Method Invocation](/records/lexicon/direct-method-invocation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-command-pattern", "title": "Command Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: behavior, state machine, lifecycle", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that gives each state of an object its own class, so behavior and legal transitions change with the state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit State Model](/records/lexicon/explicit-state-model)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism)", "term": "Reinforces" }, { "description": "[State-Local Behavior](/records/lexicon/state-local-behavior), [Legal-Transition Enforcement](/records/lexicon/legal-transition-enforcement)", "term": "Enables" }, { "description": "[Class Proliferation](/records/lexicon/class-proliferation)", "term": "In tension with" }, { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Conflicts with" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" }, { "description": "[State Pattern](/records/algorithms/state-pattern)", "term": "Contracts" }, { "description": "[State Pattern / Class Proliferation](/records/tension/class-proliferation-state-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Violated by" }, { "description": "repeated conditionals on a status field", "term": "Detected by" }, { "description": "status-conditional density", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function handleFoo(foo: Foo, event: string) {\n if (foo.status === \"draft\" && event === \"submit\") foo.status = \"review\";\n if (foo.status === \"review\" && event === \"approve\") foo.status = \"published\";\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooState { submit(): FooState; approve(): FooState; }\nconst published: FooState = { submit: () => published, approve: () => published };\nconst review: FooState = { submit: () => review, approve: () => published };\nconst draft: FooState = { submit: () => review, approve: () => draft };\nclass Foo {\n constructor(private state: FooState = draft) {}\n submit() { this.state = this.state.submit(); }\n approve() { this.state = this.state.approve(); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Explicit State Model](/records/lexicon/explicit-state-model), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Polymorphism](/records/architecture/polymorphism), [State-Local Behavior](/records/lexicon/state-local-behavior), [Legal-Transition Enforcement](/records/lexicon/legal-transition-enforcement)", "term": "Depends on" }, { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-state-pattern", "title": "State Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: behavior, request handling, pipeline", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that passes a request along an ordered list of handlers until one of them handles it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Uniform Handler Interface](/records/lexicon/uniform-handler-interface)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility)", "term": "Reinforces" }, { "description": "[Pluggable Handling](/records/lexicon/pluggable-handling), [Ordered Fallthrough](/records/lexicon/ordered-fallthrough)", "term": "Enables" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "In tension with" }, { "description": "[Monolithic Handler](/records/lexicon/monolithic-handler)", "term": "Conflicts with" }, { "description": "[Chain of Responsibility Pattern / Traceability](/records/tension/chain-of-responsibility-pattern-traceability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Monolithic Handler](/records/lexicon/monolithic-handler)", "term": "Violated by" }, { "description": "long if/else ladders handling heterogeneous requests", "term": "Detected by" }, { "description": "handler cyclomatic complexity", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function handleFoo(request: FooRequest) {\n if (request.size > MAX_SIZE) return reject(request);\n if (!request.authorized) return deny(request);\n return process(request);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooHandler = (request: FooRequest, next: () => FooResult) => FooResult;\nconst enforceSize: FooHandler = (request, next) => request.size > MAX_SIZE ? reject(request) : next();\nconst enforceAuth: FooHandler = (request, next) => request.authorized ? next() : deny(request);\nconst chain = composeHandlers([enforceSize, enforceAuth, () => process(request)]);\nchain(request);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Uniform Handler Interface](/records/lexicon/uniform-handler-interface), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Pluggable Handling](/records/lexicon/pluggable-handling), [Ordered Fallthrough](/records/lexicon/ordered-fallthrough)", "term": "Depends on" }, { "description": "[Monolithic Handler](/records/lexicon/monolithic-handler)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-chain-of-responsibility-pattern", "title": "Chain of Responsibility Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior, traversal, collection", "Aliases: Cursor", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that lets callers traverse a collection without seeing how it is stored.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Uniform Traversal Interface](/records/lexicon/uniform-traversal-interface)", "term": "Requires" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility)", "term": "Reinforces" }, { "description": "[Structure-Agnostic Iteration](/records/lexicon/structure-agnostic-iteration), [Lazy Traversal](/records/lexicon/lazy-traversal)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Exposed Internal Representation](/records/lexicon/exposed-internal-representation)", "term": "Conflicts with" }, { "description": "[Iterator Pattern / Simplicity](/records/tension/iterator-pattern-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exposed Internal Representation](/records/lexicon/exposed-internal-representation)", "term": "Violated by" }, { "description": "index/pointer traversal of another type's internals", "term": "Detected by" }, { "description": "internal-structure access count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "for (let i = 0; i < fooTree.nodes.length; i += 1) visit(fooTree.nodes[i]);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooTree {\n #roots: FooNode[] = [];\n *[Symbol.iterator](): Iterator {\n for (const node of this.#roots) yield* this.walk(node);\n }\n}\nfor (const foo of fooTree) visit(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Uniform Traversal Interface](/records/lexicon/uniform-traversal-interface), [Encapsulation](/records/architecture/encapsulation), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Structure-Agnostic Iteration](/records/lexicon/structure-agnostic-iteration), [Lazy Traversal](/records/lexicon/lazy-traversal)", "term": "Depends on" }, { "description": "[Exposed Internal Representation](/records/lexicon/exposed-internal-representation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-iterator-pattern", "title": "Iterator Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior, operation, type hierarchy", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that places each operation over a type hierarchy in its own visitor, so an operation is added without editing the element types.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Element Hierarchy](/records/lexicon/stable-element-hierarchy)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Reinforces" }, { "description": "[Operation Extension Without Element Change](/records/lexicon/operation-extension-without-element-change)", "term": "Enables" }, { "description": "[Element Stability](/records/lexicon/element-stability)", "term": "In tension with" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Conflicts with" }, { "description": "[Visitor Pattern / Element Stability](/records/tension/element-stability-visitor-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Violated by" }, { "description": "type-tag switches repeated per operation", "term": "Detected by" }, { "description": "type-switch duplication across operations", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function renderFoo(node: FooNode) {\n if (node.kind === \"text\") return node.value;\n if (node.kind === \"group\") return node.children.map(renderFoo).join(\"\");\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooVisitor { text(node: TextNode): T; group(node: GroupNode): T; }\nclass RenderFooVisitor implements FooVisitor {\n text(node: TextNode) { return node.value; }\n group(node: GroupNode) { return node.children.map(child => child.accept(this)).join(\"\"); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Stable Element Hierarchy](/records/lexicon/stable-element-hierarchy), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Separation of Concerns](/records/architecture/separation-of-concerns), [Operation Extension Without Element Change](/records/lexicon/operation-extension-without-element-change)", "term": "Depends on" }, { "description": "[Type Switching](/records/lexicon/type-switching)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-visitor-pattern", "title": "Visitor Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior, state capture, history", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which an object captures its own state in an opaque snapshot it can later restore.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Requires" }, { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Reinforces" }, { "description": "[Undo/Redo](/records/lexicon/undo-redo), [Snapshot/Restore](/records/lexicon/snapshot-restore)", "term": "Enables" }, { "description": "[Memory Footprint](/records/lexicon/memory-footprint)", "term": "In tension with" }, { "description": "[External State Reach-In](/records/lexicon/external-state-reach-in)", "term": "Conflicts with" }, { "description": "[Memento Pattern / Memory Footprint](/records/tension/memento-pattern-memory-footprint)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[External State Reach-In](/records/lexicon/external-state-reach-in)", "term": "Violated by" }, { "description": "external code reconstructing internal state", "term": "Detected by" }, { "description": "private-field external access count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const backupName = foo.name;\nconst backupTags = [...foo.tags];\nfoo.rename(newName);\nif (canceled) { foo.name = backupName; foo.tags = backupTags; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooMemento { constructor(readonly snapshot: Readonly) {} }\nconst memento = foo.save();\nfoo.rename(newName);\nif (canceled) foo.restore(memento);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding), [Undo/Redo](/records/lexicon/undo-redo), [Snapshot/Restore](/records/lexicon/snapshot-restore)", "term": "Depends on" }, { "description": "[External State Reach-In](/records/lexicon/external-state-reach-in)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-memento-pattern", "title": "Memento Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior, absence, default", "Aliases: Null Object", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that represents absence with an object implementing the expected interface as a no-op.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Behavioral Interface](/records/lexicon/shared-behavioral-interface)", "term": "Requires" }, { "description": "[Polymorphism](/records/architecture/polymorphism), [Fail-Safe Defaults](/records/lexicon/fail-safe-defaults)", "term": "Reinforces" }, { "description": "[Null-Check Elimination](/records/lexicon/null-check-elimination)", "term": "Enables" }, { "description": "[Silent No-Op Risk](/records/lexicon/silent-no-op-risk)", "term": "In tension with" }, { "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift)", "term": "Conflicts with" }, { "description": "[Null Object Pattern / Silent No-Op Risk](/records/tension/null-object-pattern-silent-no-op-risk)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Null Guards](/records/lexicon/scattered-null-guards)", "term": "Violated by" }, { "description": "repeated null checks before the same operation", "term": "Detected by" }, { "description": "null-guard density", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const logger = config.logger;\nif (logger) logger.info(\"foo saved\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooLogger { info(message: string): void; }\nconst NoopFooLogger: FooLogger = { info() {} };\nconst logger = config.logger ?? NoopFooLogger;\nlogger.info(\"foo saved\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Shared Behavioral Interface](/records/lexicon/shared-behavioral-interface), [Polymorphism](/records/architecture/polymorphism), [Fail-Safe Defaults](/records/lexicon/fail-safe-defaults), [Null-Check Elimination](/records/lexicon/null-check-elimination)", "term": "Depends on" }, { "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-null-object-pattern", "title": "Null Object Pattern" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: behavior, state modeling, control flow", "Aliases: FSM, State Machine", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of behavior as a closed set of states and the events that move between them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit State Set](/records/lexicon/explicit-state-set)", "term": "Requires" }, { "description": "[State Pattern](/records/architecture/state-pattern), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Legal-Transition Enforcement](/records/lexicon/legal-transition-enforcement), [Exhaustive State Reasoning](/records/lexicon/exhaustive-state-reasoning)", "term": "Enables" }, { "description": "[State Explosion](/records/lexicon/state-explosion)", "term": "In tension with" }, { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Conflicts with" }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Referenced by" }, { "description": "[Finite State Machine](/records/algorithms/finite-state-machine)", "term": "Contracts" }, { "description": "[Finite State Machine / State Explosion](/records/tension/finite-state-machine-state-explosion)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Violated by" }, { "description": "impossible or contradictory state combinations reachable at runtime", "term": "Detected by" }, { "description": "count of representable-but-illegal states", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "state model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "let isOpen = false, isLoading = false, isError = false;\nfunction onClick() { isLoading = true; if (isOpen) isOpen = false; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooState = \"closed\" | \"loading\" | \"open\" | \"error\";\nconst transitions: Record>> = {\n closed: { open: \"loading\" },\n loading: { ready: \"open\", fail: \"error\" },\n open: { close: \"closed\" },\n error: { retry: \"loading\" },\n};\nfunction next(state: FooState, event: FooEvent): FooState { return transitions[state][event] ?? state; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "state model review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Explicit State Set](/records/lexicon/explicit-state-set), [State Pattern](/records/architecture/state-pattern), [Correctness](/records/architecture/correctness), [Legal-Transition Enforcement](/records/lexicon/legal-transition-enforcement), [Exhaustive State Reasoning](/records/lexicon/exhaustive-state-reasoning)", "term": "Depends on" }, { "description": "[Boolean Flag Soup](/records/lexicon/boolean-flag-soup)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-finite-state-machine", "title": "Finite State Machine" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Behavioral Patterns](/records/architecture-category/behavioral-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior, state modeling, hierarchy", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a state machine extended with nested states and parallel regions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Requires" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine), [Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Reinforces" }, { "description": "[Hierarchical States](/records/lexicon/hierarchical-states), [Parallel Regions](/records/lexicon/parallel-regions), [Guarded Transitions](/records/lexicon/guarded-transitions)", "term": "Enables" }, { "description": "[Tooling Complexity](/records/lexicon/tooling-complexity)", "term": "In tension with" }, { "description": "[Flat State Explosion](/records/lexicon/flat-state-explosion)", "term": "Conflicts with" }, { "description": "[Statecharts](/records/algorithms/statecharts)", "term": "Contracts" }, { "description": "[Statecharts / Tooling Complexity](/records/tension/statecharts-tooling-complexity)", "term": "Tensions" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine): A finite state machine is flat states and events, while statecharts add nested states and parallel regions to it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Flat State Explosion](/records/lexicon/flat-state-explosion)", "term": "Violated by" }, { "description": "combinatorial state growth from independent concerns modeled in one flat machine", "term": "Detected by" }, { "description": "transition duplication across sibling states", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "state model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type S = \"idleMuted\" | \"idleLoud\" | \"playingMuted\" | \"playingLoud\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooChart = {\n initial: \"idle\",\n states: { idle: {}, playing: {} },\n parallel: { volume: { states: { muted: {}, loud: {} } } },\n};", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "state model review", "term": "Checked by" }, { "description": "Every module whose behavior varies by mode, state, request kind or traversal", "term": "Population" }, { "description": "A verdict stands until the module's branching or its state model changes", "term": "Freshness" }, { "description": "The review or the complexity threshold rejects the change that reintroduces the branching the pattern removes", "term": "Refusal" }, { "description": "Conditional complexity and dispatch counts read from source, and the recorded design review", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The pattern's dispatch structure, which a change to the module's branching is compared against", "term": "Authoritative side" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine), [Finite State Machine](/records/architecture/finite-state-machine), [Separation of Concerns](/records/architecture/separation-of-concerns), [Hierarchical States](/records/lexicon/hierarchical-states), [Parallel Regions](/records/lexicon/parallel-regions), [Guarded Transitions](/records/lexicon/guarded-transitions)", "term": "Depends on" }, { "description": "[Flat State Explosion](/records/lexicon/flat-state-explosion)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-statecharts", "title": "Statecharts" } ], "title": "Behavioral Patterns" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_factory_pattern[\"Factory Pattern\"]\n n_factory_method_pattern[\"Factory Method Pattern\"]\n n_abstract_factory_pattern[\"Abstract Factory Pattern\"]\n n_builder_pattern[\"Builder Pattern\"]\n n_prototype_pattern[\"Prototype Pattern\"]\n n_singleton_pattern[\"Singleton Pattern\"]" } ], "icon": "bi-collection", "id": "architecture-category-creational-patterns", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: [object_creation](/records/force/object-creation), module", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that moves the construction of an object and its defaults into one function or object.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Creation Variation](/records/lexicon/creation-variation)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Encapsulation](/records/architecture/encapsulation)", "term": "Reinforces" }, { "description": "[Polymorphic Construction](/records/lexicon/polymorphic-construction)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "In tension with" }, { "description": "[Scattered Construction Logic](/records/lexicon/scattered-construction-logic)", "term": "Conflicts with" }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" }, { "description": "[Factory Pattern / Simplicity](/records/tension/factory-pattern-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Construction Logic](/records/lexicon/scattered-construction-logic)", "term": "Violated by" }, { "description": "repeated constructors/switches", "term": "Detected by" }, { "description": "construction duplication count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "creation policy review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = new Foo(\"foo\", 0, [], new Date(), \"draft\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function makeFoo(name: string): Foo {\n return new Foo(fooId(), name, 0, [], clock.now(), \"draft\");\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "creation policy review", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Creation Variation](/records/lexicon/creation-variation), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Encapsulation](/records/architecture/encapsulation), [Polymorphic Construction](/records/lexicon/polymorphic-construction)", "term": "Depends on" }, { "description": "[Scattered Construction Logic](/records/lexicon/scattered-construction-logic)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-factory-pattern", "title": "Factory Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: class hierarchy, framework", "Aliases: Virtual Constructor", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which a base class calls an overridable method to create the objects its workflow uses.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Subclass-Controlled Creation](/records/lexicon/subclass-controlled-creation)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Reinforces" }, { "description": "[Deferred Instantiation](/records/lexicon/deferred-instantiation)", "term": "Enables" }, { "description": "[Inheritance Complexity](/records/lexicon/inheritance-complexity)", "term": "In tension with" }, { "description": "[Concrete Constructor Coupling](/records/lexicon/concrete-constructor-coupling)", "term": "Conflicts with" }, { "description": "[Factory Method Pattern / Inheritance Complexity](/records/tension/factory-method-pattern-inheritance-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Concrete Constructor Coupling](/records/lexicon/concrete-constructor-coupling)", "term": "Violated by" }, { "description": "base class directly instantiates variant", "term": "Detected by" }, { "description": "variant construction duplication", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooImporter {\n import(raw: string) { return new JsonFooParser().parse(raw); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "abstract class FooImporter {\n protected abstract parser(): FooParser;\n import(raw: string) { return this.parser().parse(raw); }\n}\nclass JsonFooImporter extends FooImporter {\n protected parser() { return new JsonFooParser(); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Subclass-Controlled Creation](/records/lexicon/subclass-controlled-creation), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Deferred Instantiation](/records/lexicon/deferred-instantiation)", "term": "Depends on" }, { "description": "[Concrete Constructor Coupling](/records/lexicon/concrete-constructor-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-factory-method-pattern", "title": "Factory Method Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: product family, component", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that creates a whole family of related objects through one interface, so the members always match.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Related Product Variants](/records/lexicon/related-product-variants)", "term": "Requires" }, { "description": "[Interchangeability](/records/architecture/interchangeability)", "term": "Reinforces" }, { "description": "[Family-Level Replacement](/records/lexicon/family-level-replacement)", "term": "Enables" }, { "description": "[Boilerplate](/records/lexicon/boilerplate)", "term": "In tension with" }, { "description": "[Mixed Product Families](/records/lexicon/mixed-product-families)", "term": "Conflicts with" }, { "description": "[Abstract Factory Pattern / Boilerplate](/records/tension/abstract-factory-pattern-boilerplate)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Mixed Product Families](/records/lexicon/mixed-product-families)", "term": "Violated by" }, { "description": "manual selection of related product classes", "term": "Detected by" }, { "description": "family mismatch defects", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "factory conformance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const store = env === \"test\" ? new MemoryFooStore() : new SqlFooStore();\nconst bus = env === \"test\" ? new MemoryFooBus() : new KafkaFooBus();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooPlatformFactory {\n store(): FooStore;\n bus(): FooBus;\n}\nclass TestFooPlatformFactory implements FooPlatformFactory {\n store() { return new MemoryFooStore(); }\n bus() { return new MemoryFooBus(); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "factory conformance tests", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Related Product Variants](/records/lexicon/related-product-variants), [Interchangeability](/records/architecture/interchangeability), [Family-Level Replacement](/records/lexicon/family-level-replacement)", "term": "Depends on" }, { "description": "[Mixed Product Families](/records/lexicon/mixed-product-families)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-abstract-factory-pattern", "title": "Abstract Factory Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: object construction, API", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that assembles a complex object step by step through named calls and validates it when it is built.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Complex Construction](/records/lexicon/complex-construction)", "term": "Requires" }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Reinforces" }, { "description": "[Valid Object Creation](/records/lexicon/valid-object-creation)", "term": "Enables" }, { "description": "[Boilerplate](/records/lexicon/boilerplate)", "term": "In tension with" }, { "description": "[Telescoping Constructor](/records/lexicon/telescoping-constructor)", "term": "Conflicts with" }, { "description": "[Builder Pattern / Boilerplate](/records/tension/boilerplate-builder-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Telescoping Constructor](/records/lexicon/telescoping-constructor)", "term": "Violated by" }, { "description": "high-arity constructors", "term": "Detected by" }, { "description": "constructor parameter count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "API review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = new Foo(\"foo_1\", \"Foo\", [], 0, false, undefined, \"draft\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = new FooBuilder()\n .withId(\"foo_1\")\n .withName(\"Foo\")\n .withStatus(\"draft\")\n .build();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API review", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Complex Construction](/records/lexicon/complex-construction), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Valid Object Creation](/records/lexicon/valid-object-creation)", "term": "Depends on" }, { "description": "[Telescoping Constructor](/records/lexicon/telescoping-constructor)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-builder-pattern", "title": "Builder Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: [object_creation](/records/force/object-creation), runtime", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that creates new objects by cloning a prepared template and applying overrides.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Cloneable Template Object](/records/lexicon/cloneable-template-object)", "term": "Requires" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Reinforces" }, { "description": "[Dynamic Object Creation](/records/lexicon/dynamic-object-creation)", "term": "Enables" }, { "description": "[Copy Semantics](/records/lexicon/copy-semantics)", "term": "In tension with" }, { "description": "[Complex Factory Hierarchies](/records/lexicon/complex-factory-hierarchies)", "term": "Conflicts with" }, { "description": "[Prototype Pattern / Copy Semantics](/records/tension/copy-semantics-prototype-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Repeated Expensive Setup](/records/lexicon/repeated-expensive-setup)", "term": "Violated by" }, { "description": "duplicate initialization flows", "term": "Detected by" }, { "description": "initialization duplication/cost", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "clone tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function copyFoo(foo: Foo) {\n return new Foo(foo.id, foo.name, [...foo.tags], foo.settings.theme, foo.settings.mode);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooPrototype {\n constructor(private readonly base: Foo) {}\n clone(overrides: Partial = {}): Foo {\n return structuredClone({ ...this.base, ...overrides });\n }\n}\nconst template = new FooPrototype(await buildExpensiveFoo());\nconst draft = template.clone({ name: \"quick\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "clone tests", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Cloneable Template Object](/records/lexicon/cloneable-template-object), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Dynamic Object Creation](/records/lexicon/dynamic-object-creation)", "term": "Depends on" }, { "description": "[Complex Factory Hierarchies](/records/lexicon/complex-factory-hierarchies)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-prototype-pattern", "title": "Prototype Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Creational Patterns](/records/architecture-category/creational-patterns)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: [object_creation](/records/force/object-creation), lifetime, composition root", "Aliases: Singleton", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that restricts a class to one instance, reached through a global access point.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Single-Instance Need](/records/lexicon/single-instance-need)", "term": "Requires" }, { "description": "[Controlled Instantiation](/records/lexicon/controlled-instantiation)", "term": "Reinforces" }, { "description": "[Shared Resource Access](/records/lexicon/shared-resource-access)", "term": "Enables" }, { "description": "[Testability](/records/architecture/testability), [Dependency Injection](/records/architecture/dependency-injection)", "term": "In tension with" }, { "description": "[Global Mutable State](/records/lexicon/global-mutable-state)", "term": "Conflicts with" }, { "description": "[Singleton Pattern / Testability](/records/tension/singleton-pattern-testability), [Singleton Pattern / Dependency Injection](/records/tension/dependency-injection-singleton-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Global Mutable State](/records/lexicon/global-mutable-state)", "term": "Violated by" }, { "description": "static global access to a shared service", "term": "Detected by" }, { "description": "global-instance reach-in count", "term": "Measured by" }, { "description": "[Composition Root](/records/lexicon/composition-root), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "composition-root review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "let instance: FooService | undefined;\nfunction getFooService() { return instance ??= new FooService(); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {}\nexport function composeApp() {\n const fooService = new FooService();\n return { fooService, fooController: new FooController(fooService) };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "composition-root review", "term": "Checked by" }, { "description": "Every construction site of the types the pattern governs", "term": "Population" }, { "description": "A verdict stands until a constructor, a variant or the composition root changes", "term": "Freshness" }, { "description": "The review or the construction test rejects a construction that bypasses the creational owner", "term": "Refusal" }, { "description": "Constructor call sites and their argument counts, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The creational owner, which every construction site goes through", "term": "Authoritative side" }, { "description": "[Single-Instance Need](/records/lexicon/single-instance-need), [Controlled Instantiation](/records/lexicon/controlled-instantiation), [Shared Resource Access](/records/lexicon/shared-resource-access)", "term": "Depends on" }, { "description": "[Global Mutable State](/records/lexicon/global-mutable-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-singleton-pattern", "title": "Singleton Pattern" } ], "title": "Creational Patterns" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_adapter_pattern[\"Adapter Pattern\"]\n n_facade_pattern[\"Facade Pattern\"]\n n_proxy_pattern[\"Proxy Pattern\"]\n n_bridge_pattern[\"Bridge Pattern\"]\n n_decorator_pattern[\"Decorator Pattern\"]\n n_composite_pattern[\"Composite Pattern\"]\n n_flyweight_pattern[\"Flyweight Pattern\"]" } ], "icon": "bi-collection", "id": "architecture-category-structural-patterns", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: integration, boundary", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that wraps a component with an incompatible interface so it implements the interface its callers expect.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Incompatible Interfaces](/records/lexicon/incompatible-interfaces)", "term": "Requires" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Replaceability](/records/architecture/replaceability)", "term": "Reinforces" }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Enables" }, { "description": "[Mapping Overhead](/records/lexicon/mapping-overhead)", "term": "In tension with" }, { "description": "[Direct External Coupling](/records/lexicon/direct-external-coupling)", "term": "Conflicts with" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design)", "term": "Referenced by" }, { "description": "[Adapter Pattern / Mapping Overhead](/records/tension/adapter-pattern-mapping-overhead)", "term": "Tensions" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer): An adapter fits one incompatible interface to the one expected, while an anti-corruption layer translates a whole external model into the local domain's terms.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct External Coupling](/records/lexicon/direct-external-coupling)", "term": "Violated by" }, { "description": "external SDK types in domain/application", "term": "Detected by" }, { "description": "external leakage count", "term": "Measured by" }, { "description": "[Extract Adapter](/records/lexicon/extract-adapter), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Refactored by" }, { "description": "boundary import rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) {\n return legacyClient.put(foo.id, foo.name, foo.count);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class LegacyFooAdapter implements FooStore {\n constructor(private readonly client: LegacyClient) {}\n save(foo: Foo) { return this.client.put(foo.id, foo.name, foo.count); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "boundary import rules", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Incompatible Interfaces](/records/lexicon/incompatible-interfaces), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Replaceability](/records/architecture/replaceability), [Interoperability](/records/architecture/interoperability)", "term": "Depends on" }, { "description": "[Direct External Coupling](/records/lexicon/direct-external-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-adapter-pattern", "title": "Adapter Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: module, subsystem, API", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that gives a subsystem one simple entry point, so callers do not depend on its parts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Subsystem Complexity](/records/lexicon/subsystem-complexity)", "term": "Requires" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding)", "term": "Reinforces" }, { "description": "[Simplified Access](/records/lexicon/simplified-access)", "term": "Enables" }, { "description": "[Over-Centralization](/records/lexicon/over-centralization)", "term": "In tension with" }, { "description": "[Leaky Subsystem API](/records/lexicon/leaky-subsystem-api)", "term": "Conflicts with" }, { "description": "[Facade Pattern / Over-Centralization](/records/tension/facade-pattern-over-centralization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Leaky Subsystem API](/records/lexicon/leaky-subsystem-api)", "term": "Violated by" }, { "description": "broad dependency surface to subsystem", "term": "Detected by" }, { "description": "consumer dependency count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "API boundary rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = fooValidator.validate(fooParser.parse(raw));\nawait fooStore.save(foo);\nawait fooEvents.publish(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooFacade {\n async create(raw: string) {\n const foo = fooValidator.validate(fooParser.parse(raw));\n await fooStore.save(foo);\n await fooEvents.publish(foo);\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API boundary rules", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Subsystem Complexity](/records/lexicon/subsystem-complexity), [Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding), [Simplified Access](/records/lexicon/simplified-access)", "term": "Depends on" }, { "description": "[Leaky Subsystem API](/records/lexicon/leaky-subsystem-api)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-facade-pattern", "title": "Facade Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: access control, remote access, lazy loading", "Aliases: Surrogate", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that places a stand-in with the same interface in front of an object, to control, defer or cache access to it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Controlled Access](/records/lexicon/controlled-access)", "term": "Requires" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Security](/records/lexicon/security)", "term": "Reinforces" }, { "description": "[Lazy Load](/records/lexicon/lazy-load), [Authorization](/records/architecture/authorization), [Remote Stub](/records/lexicon/remote-stub)", "term": "Enables" }, { "description": "[Transparency / Debugging](/records/lexicon/transparency-debugging)", "term": "In tension with" }, { "description": "[Direct Access](/records/lexicon/direct-access)", "term": "Conflicts with" }, { "description": "[Proxy Pattern / Transparency / Debugging](/records/tension/proxy-pattern-transparency-debugging)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct Access](/records/lexicon/direct-access)", "term": "Violated by" }, { "description": "bypassed access wrapper", "term": "Detected by" }, { "description": "proxy bypass count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "access rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function loadFoo(id: FooId) { return remoteFooStore.find(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class CachingFooStoreProxy implements FooStore {\n constructor(private readonly target: FooStore) {}\n async find(id: FooId) {\n const cached = fooCache.get(id);\n if (cached) return cached;\n const foo = await this.target.find(id);\n fooCache.set(id, foo);\n return foo;\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "access rules", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Controlled Access](/records/lexicon/controlled-access), [Encapsulation](/records/architecture/encapsulation), [Security](/records/lexicon/security), [Lazy Load](/records/lexicon/lazy-load), [Authorization](/records/architecture/authorization), [Remote Stub](/records/lexicon/remote-stub)", "term": "Depends on" }, { "description": "[Direct Access](/records/lexicon/direct-access)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-proxy-pattern", "title": "Proxy Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: abstraction, implementation variation", "Aliases: Handle-Body", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that separates two independent axes of variation into two hierarchies joined by composition.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Independent Variation Axes](/records/lexicon/independent-variation-axes)", "term": "Requires" }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Reinforces" }, { "description": "[Implementation Swap](/records/lexicon/implementation-swap)", "term": "Enables" }, { "description": "[Indirection](/records/lexicon/indirection)", "term": "In tension with" }, { "description": "[Cartesian Inheritance Explosion](/records/lexicon/cartesian-inheritance-explosion)", "term": "Conflicts with" }, { "description": "[Bridge Pattern / Indirection](/records/tension/bridge-pattern-indirection)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Cartesian Inheritance Explosion](/records/lexicon/cartesian-inheritance-explosion)", "term": "Violated by" }, { "description": "parallel hierarchies / deep variant classes", "term": "Detected by" }, { "description": "variant class count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class SqlJsonFooExporter {}\nclass SqlCsvFooExporter {}\nclass MemoryJsonFooExporter {}\nclass MemoryCsvFooExporter {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooSource { read(): Promise; }\ninterface FooFormat { encode(foos: readonly Foo[]): string; }\nclass FooExporter {\n constructor(private readonly source: FooSource, private readonly format: FooFormat) {}\n async export() { return this.format.encode(await this.source.read()); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Independent Variation Axes](/records/lexicon/independent-variation-axes), [Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Implementation Swap](/records/lexicon/implementation-swap)", "term": "Depends on" }, { "description": "[Cartesian Inheritance Explosion](/records/lexicon/cartesian-inheritance-explosion)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-bridge-pattern", "title": "Bridge Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: behavior composition", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that adds behavior to an object by wrapping it in another object with the same interface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Common Interface](/records/lexicon/common-interface)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Composability](/records/architecture/composability)", "term": "Reinforces" }, { "description": "[Runtime Behavior Extension](/records/lexicon/runtime-behavior-extension)", "term": "Enables" }, { "description": "[Stack Debugging](/records/lexicon/stack-debugging)", "term": "In tension with" }, { "description": "[Subclass Explosion](/records/lexicon/subclass-explosion)", "term": "Conflicts with" }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Referenced by" }, { "description": "[Decorator Pattern / Stack Debugging](/records/tension/decorator-pattern-stack-debugging)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Subclass Explosion](/records/lexicon/subclass-explosion)", "term": "Violated by" }, { "description": "repeated wrapper-like subclasses", "term": "Detected by" }, { "description": "variant explosion count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "interface conformance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class LoggedSqlFooStore extends SqlFooStore {\n override save(foo: Foo) { logger.info(\"foo.saved\", { fooId: foo.id }); return super.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class LoggedFooStore implements FooStore {\n constructor(private readonly inner: FooStore, private readonly log: Log) {}\n save(foo: Foo) { this.log.write(foo.id); return this.inner.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "interface conformance tests", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Common Interface](/records/lexicon/common-interface), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Composability](/records/architecture/composability), [Runtime Behavior Extension](/records/lexicon/runtime-behavior-extension)", "term": "Depends on" }, { "description": "[Subclass Explosion](/records/lexicon/subclass-explosion)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-decorator-pattern", "title": "Decorator Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: structure, tree, hierarchy", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that gives leaves and groups one interface, so a tree is traversed without checking which kind each node is.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Uniform Component Interface](/records/lexicon/uniform-component-interface)", "term": "Requires" }, { "description": "[Uniform Interface](/records/architecture/uniform-interface), [Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Reinforces" }, { "description": "[Recursive Composition](/records/lexicon/recursive-composition), [Leaf/Composite Transparency](/records/lexicon/leaf-composite-transparency)", "term": "Enables" }, { "description": "[Type Safety](/records/architecture/type-safety)", "term": "In tension with" }, { "description": "[Leaf-vs-Container Special-Casing](/records/lexicon/leaf-vs-container-special-casing)", "term": "Conflicts with" }, { "description": "[Composite Pattern / Type Safety](/records/tension/composite-pattern-type-safety)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Leaf-vs-Container Special-Casing](/records/lexicon/leaf-vs-container-special-casing)", "term": "Violated by" }, { "description": "isContainer/isLeaf conditionals during traversal", "term": "Detected by" }, { "description": "node-kind conditional count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function totalFoo(item: Foo | FooGroup): number {\n if (\"children\" in item) return item.children.reduce((sum, child) => sum + totalFoo(child), 0);\n return item.value;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooComponent { total(): number; }\nclass FooLeaf implements FooComponent {\n constructor(private readonly value: number) {}\n total() { return this.value; }\n}\nclass FooGroup implements FooComponent {\n constructor(private readonly children: readonly FooComponent[]) {}\n total() { return this.children.reduce((sum, child) => sum + child.total(), 0); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Uniform Component Interface](/records/lexicon/uniform-component-interface), [Uniform Interface](/records/architecture/uniform-interface), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Recursive Composition](/records/lexicon/recursive-composition), [Leaf/Composite Transparency](/records/lexicon/leaf-composite-transparency)", "term": "Depends on" }, { "description": "[Leaf-vs-Container Special-Casing](/records/lexicon/leaf-vs-container-special-casing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-composite-pattern", "title": "Composite Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Structural Patterns](/records/architecture-category/structural-patterns)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: structure, memory, sharing", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that shares one copy of immutable intrinsic state among many objects, each keeping only its own extrinsic state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Separable Intrinsic State](/records/lexicon/separable-intrinsic-state)", "term": "Requires" }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Reinforces" }, { "description": "[Shared Immutable State](/records/lexicon/shared-immutable-state), [High-Cardinality Object Reuse](/records/lexicon/high-cardinality-object-reuse)", "term": "Enables" }, { "description": "[Complexity](/records/lexicon/complexity)", "term": "In tension with" }, { "description": "[Per-Instance Duplicate State](/records/lexicon/per-instance-duplicate-state)", "term": "Conflicts with" }, { "description": "[Flyweight Pattern / Complexity](/records/tension/complexity-flyweight-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Per-Instance Duplicate State](/records/lexicon/per-instance-duplicate-state)", "term": "Violated by" }, { "description": "repeated equal intrinsic state across objects", "term": "Detected by" }, { "description": "duplicate-state memory footprint", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "profiling review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const icons = foos.map(foo => new FooIcon(foo.position, loadSprite(foo.kind)));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const spriteCache = new Map();\nfunction fooSprite(kind: string) {\n const cached = spriteCache.get(kind);\n if (cached) return cached;\n const sprite = loadSprite(kind);\n spriteCache.set(kind, sprite);\n return sprite;\n}\nconst icons = foos.map(foo => ({ position: foo.position, sprite: fooSprite(foo.kind) }));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "profiling review", "term": "Checked by" }, { "description": "Every boundary, wrapper and composite structure that sits between a caller and the objects it uses", "term": "Population" }, { "description": "A verdict stands until the wrapped interface or its callers change", "term": "Freshness" }, { "description": "The boundary import rule or the conformance test fails a caller that reaches past the structure", "term": "Refusal" }, { "description": "Imports and call sites that cross the structure, read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The structure's interface, which every caller goes through", "term": "Authoritative side" }, { "description": "[Separable Intrinsic State](/records/lexicon/separable-intrinsic-state), [Memory Efficiency](/records/architecture/memory-efficiency), [Shared Immutable State](/records/lexicon/shared-immutable-state), [High-Cardinality Object Reuse](/records/lexicon/high-cardinality-object-reuse)", "term": "Depends on" }, { "description": "[Per-Instance Duplicate State](/records/lexicon/per-instance-duplicate-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-flyweight-pattern", "title": "Flyweight Pattern" } ], "title": "Structural Patterns" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_scalability[\"Scalability\"]\n n_horizontal_scaling[\"Horizontal Scaling\"]\n n_vertical_scaling[\"Vertical Scaling\"]\n n_elasticity[\"Elasticity\"]\n n_load_balancing[\"Load Balancing\"]\n n_sharding[\"Sharding\"]\n n_partitioning[\"Partitioning\"]\n n_caching[\"Caching\"]\n n_statelessness[\"Statelessness\"]\n n_concurrency[\"Concurrency\"]\n n_parallelism[\"Parallelism\"]\n n_throughput[\"Throughput\"]\n n_latency[\"Latency\"]\n n_performance_engineering[\"Performance Engineering\"]\n n_algorithmic_efficiency[\"Algorithmic Efficiency\"]\n n_time_complexity[\"Time Complexity\"]\n n_space_complexity[\"Space Complexity\"]\n n_big_o_notation[\"Big O Notation\"]\n n_optimization[\"Optimization\"]\n n_profiling[\"Profiling\"]\n n_benchmarking[\"Benchmarking\"]\n n_bottleneck_analysis[\"Bottleneck Analysis\"]\n n_resource_utilization[\"Resource Utilization\"]\n n_rate_limiting[\"Rate Limiting\"]\n n_memory_efficiency[\"Memory Efficiency\"]\n n_cdn_edge_caching[\"CDN / Edge Caching\"]\n n_read_replica[\"Read Replica\"]\n n_queuing_theory[\"Queuing Theory\"]\n n_scalability --> n_performance_engineering\n n_horizontal_scaling --> n_elasticity\n n_elasticity --> n_scalability\n n_load_balancing --> n_scalability\n n_sharding --> n_horizontal_scaling\n n_partitioning --> n_scalability\n n_partitioning --> n_parallelism\n n_caching --> n_scalability\n n_statelessness --> n_horizontal_scaling\n n_statelessness --> n_load_balancing\n n_concurrency --> n_throughput\n n_parallelism --> n_throughput\n n_throughput --> n_scalability\n n_throughput -.-> n_latency\n n_latency --> n_performance_engineering\n n_performance_engineering --> n_profiling\n n_performance_engineering --> n_benchmarking\n n_performance_engineering --> n_scalability\n n_algorithmic_efficiency --> n_scalability\n n_time_complexity --> n_algorithmic_efficiency\n n_time_complexity -.-> n_space_complexity\n n_space_complexity --> n_resource_utilization\n n_space_complexity -.-> n_time_complexity\n n_big_o_notation --> n_algorithmic_efficiency\n n_optimization --> n_profiling\n n_optimization --> n_performance_engineering\n n_profiling --> n_performance_engineering\n n_benchmarking --> n_performance_engineering\n n_bottleneck_analysis --> n_profiling\n n_bottleneck_analysis --> n_optimization\n n_resource_utilization --> n_performance_engineering\n n_memory_efficiency --> n_scalability\n n_cdn_edge_caching --> n_caching\n n_cdn_edge_caching --> n_latency\n n_read_replica --> n_horizontal_scaling\n n_read_replica --> n_load_balancing\n n_queuing_theory --> n_latency" } ], "icon": "bi-collection", "id": "architecture-category-scalability-performance-optimization", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, system, infrastructure", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system keeps its throughput and latency as load grows, by adding resources.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Load Model](/records/lexicon/load-model), [Bottleneck Awareness](/records/lexicon/bottleneck-awareness)", "term": "Requires" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Growth Handling](/records/lexicon/growth-handling)", "term": "Enables" }, { "description": "[Simplicity](/records/lexicon/simplicity), [Consistency](/records/architecture/consistency)", "term": "In tension with" }, { "description": "[Fixed-Capacity Design](/records/lexicon/fixed-capacity-design)", "term": "Conflicts with" }, { "description": "[Service Discovery](/records/architecture/service-discovery), [Message Broker](/records/architecture/message-broker), [Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation), [Eventual Consistency](/records/architecture/eventual-consistency), [Elasticity](/records/architecture/elasticity), [Load Balancing](/records/architecture/load-balancing), [Partitioning](/records/architecture/partitioning), [Caching](/records/architecture/caching), [Throughput](/records/architecture/throughput), [Performance Engineering](/records/architecture/performance-engineering), [Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Memory Efficiency](/records/architecture/memory-efficiency), [Stateless Processing](/records/architecture/stateless-processing), [Replication](/records/architecture/replication), [Microservices](/records/architecture/microservices)", "term": "Referenced by" }, { "description": "[Scalability / Simplicity](/records/tension/scalability-simplicity), [Scalability / Consistency](/records/tension/consistency-scalability)", "term": "Tensions" }, { "description": "[Elasticity](/records/architecture/elasticity): Scalability is keeping throughput as load grows by adding resources, while elasticity is those resources following demand automatically in both directions.", "term": "Distinct from" }, { "description": "[Low Coupling](/records/architecture/low-coupling): Scalability is growing with load, while low coupling is changing without ripple.", "term": "Distinct from" }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency): Scalability is growth by adding resources, while memory efficiency is bounded use of the resources one process has.", "term": "Distinct from" }, { "description": "[Resilience](/records/architecture/resilience): Scalability is holding performance under load, while resilience is containing and recovering from failure.", "term": "Distinct from" }, { "description": "[Testability](/records/architecture/testability): Scalability is growing with load, while testability is running code in isolation.", "term": "Distinct from" }, { "description": "[Cost Efficiency](/records/lexicon/cost-efficiency): Scalability is keeping throughput as load grows, while cost efficiency is the resource cost of the work.", "term": "Distinct from" }, { "description": "[Resource Efficiency](/records/lexicon/resource-efficiency): Scalability adds resources to meet load, while resource efficiency uses as few as possible for the same work.", "term": "Distinct from" }, { "description": "[Simplicity](/records/lexicon/simplicity): Scalability is growth with load, while simplicity is the absence of the structure that growth tends to add.", "term": "Distinct from" }, { "description": "[Availability](/records/lexicon/availability): Scalability is performance under growing load, while availability is the share of time the system serves at all.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Bottlenecks](/records/lexicon/bottlenecks)", "term": "Violated by" }, { "description": "saturation under load test", "term": "Detected by" }, { "description": "throughput under increasing load", "term": "Measured by" }, { "description": "[Caching](/records/architecture/caching), [Partitioning](/records/architecture/partitioning), [Introduce Async Event](/records/lexicon/introduce-async-event), [Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Refactored by" }, { "description": "load tests, SLO gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooServer {\n private readonly foos = new Map();\n handle(request: FooRequest) { return processFoo(request, this.foos); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooServer {\n constructor(private readonly store: DistributedFooStore) {}\n handle(request: FooRequest) { return processFoo(request, this.store); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "load tests, SLO gates", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Load Model](/records/lexicon/load-model), [Bottleneck Awareness](/records/lexicon/bottleneck-awareness), [Performance Engineering](/records/architecture/performance-engineering), [Growth Handling](/records/lexicon/growth-handling)", "term": "Depends on" }, { "description": "[Fixed-Capacity Design](/records/lexicon/fixed-capacity-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-scalability", "title": "Scalability" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, infrastructure", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding capacity by running more stateless instances of a service behind a load balancer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Statelessness or Shared State Strategy](/records/lexicon/statelessness-or-shared-state-strategy)", "term": "Requires" }, { "description": "[Elasticity](/records/architecture/elasticity), [Availability](/records/lexicon/availability)", "term": "Reinforces" }, { "description": "[Scale-Out](/records/lexicon/scale-out)", "term": "Enables" }, { "description": "[Distributed Coordination](/records/lexicon/distributed-coordination)", "term": "In tension with" }, { "description": "[Instance-Local State](/records/lexicon/instance-local-state)", "term": "Conflicts with" }, { "description": "[Competing Consumers](/records/architecture/competing-consumers), [Sharding](/records/architecture/sharding), [Statelessness](/records/architecture/statelessness), [Read Replica](/records/architecture/read-replica), [Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Referenced by" }, { "description": "[Horizontal Scaling / Distributed Coordination](/records/tension/distributed-coordination-horizontal-scaling)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Instance Affinity](/records/lexicon/instance-affinity)", "term": "Violated by" }, { "description": "local session/state coupling", "term": "Detected by" }, { "description": "scale-out efficiency", "term": "Measured by" }, { "description": "[Externalize Session State](/records/lexicon/externalize-session-state), [Load Balancing](/records/architecture/load-balancing)", "term": "Refactored by" }, { "description": "deployment tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployFoo({ replicas: 1, cpu: 32, memoryGb: 128 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "deployFoo({ replicas: 12, cpu: 2, memoryGb: 4, stateless: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment tests", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Statelessness or Shared State Strategy](/records/lexicon/statelessness-or-shared-state-strategy), [Elasticity](/records/architecture/elasticity), [Availability](/records/lexicon/availability), [Scale-Out](/records/lexicon/scale-out)", "term": "Depends on" }, { "description": "[Instance-Local State](/records/lexicon/instance-local-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-horizontal-scaling", "title": "Horizontal Scaling" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: infrastructure, process", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding capacity by giving one instance more CPU, memory or I/O.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Resource Headroom](/records/lexicon/resource-headroom)", "term": "Requires" }, { "description": "[Simplicity](/records/lexicon/simplicity)", "term": "Reinforces" }, { "description": "[Capacity Increase without Distribution](/records/lexicon/capacity-increase-without-distribution)", "term": "Enables" }, { "description": "[Cost/Limit](/records/lexicon/cost-limit)", "term": "In tension with" }, { "description": "[Hard Resource Ceiling](/records/lexicon/hard-resource-ceiling)", "term": "Conflicts with" }, { "description": "[Vertical Scaling / Cost/Limit](/records/tension/cost-limit-vertical-scaling)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hard Resource Ceiling](/records/lexicon/hard-resource-ceiling)", "term": "Violated by" }, { "description": "resource saturation trends", "term": "Detected by" }, { "description": "utilization/headroom", "term": "Measured by" }, { "description": "[Profiling](/records/architecture/profiling), [Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Refactored by" }, { "description": "[capacity planning](/records/lexicon/capacity-planning)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployFoo({ cpu: 1, memoryGb: 1 });\nqueueFooWhenSaturated();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "deployFoo({ cpu: 8, memoryGb: 32 });\nverifyFooCapacity({ targetConcurrency: 200 });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "capacity planning", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Resource Headroom](/records/lexicon/resource-headroom), [Simplicity](/records/lexicon/simplicity), [Capacity Increase without Distribution](/records/lexicon/capacity-increase-without-distribution)", "term": "Depends on" }, { "description": "[Hard Resource Ceiling](/records/lexicon/hard-resource-ceiling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-vertical-scaling", "title": "Vertical Scaling" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: deployment, infrastructure", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system's provisioned capacity follows demand up and down automatically.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Auto-Scaling](/records/architecture/auto-scaling), [Metrics](/records/lexicon/metrics)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Cost Efficiency](/records/lexicon/cost-efficiency)", "term": "Reinforces" }, { "description": "[Dynamic Capacity](/records/lexicon/dynamic-capacity)", "term": "Enables" }, { "description": "[Warm-Up Latency](/records/lexicon/warm-up-latency)", "term": "In tension with" }, { "description": "[Fixed Provisioning](/records/lexicon/fixed-provisioning)", "term": "Conflicts with" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Auto-Scaling](/records/architecture/auto-scaling), [Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Referenced by" }, { "description": "[Elasticity / Warm-Up Latency](/records/tension/elasticity-warm-up-latency)", "term": "Tensions" }, { "description": "[Availability](/records/lexicon/availability): Elasticity is capacity following demand, while availability is the share of time the system can serve.", "term": "Distinct from" }, { "description": "[Cost Efficiency](/records/lexicon/cost-efficiency): Elasticity is capacity following demand, while cost efficiency is the work done per unit of resource cost.", "term": "Distinct from" }, { "description": "[Warm-Up Latency](/records/lexicon/warm-up-latency): Elasticity adds capacity when demand rises, while warm-up latency is the delay before that capacity can serve.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fixed Provisioning](/records/lexicon/fixed-provisioning)", "term": "Violated by" }, { "description": "under/over-provisioning patterns", "term": "Detected by" }, { "description": "scale response time, utilization", "term": "Measured by" }, { "description": "[Autoscaling Policy](/records/lexicon/autoscaling-policy), [Externalize Session State](/records/lexicon/externalize-session-state)", "term": "Refactored by" }, { "description": "infrastructure policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployFooWorkers({ replicas: 10 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "deployFooWorkers({\n minReplicas: 2,\n maxReplicas: 50,\n target: { queueDepthPerReplica: 100 },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure policy", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Auto-Scaling](/records/architecture/auto-scaling), [Metrics](/records/lexicon/metrics), [Scalability](/records/architecture/scalability), [Cost Efficiency](/records/lexicon/cost-efficiency), [Dynamic Capacity](/records/lexicon/dynamic-capacity)", "term": "Depends on" }, { "description": "[Fixed Provisioning](/records/lexicon/fixed-provisioning)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-elasticity", "title": "Elasticity" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: traffic, service", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that spreads incoming requests across healthy instances of a service.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Multiple Targets](/records/lexicon/multiple-targets), [Health Checks](/records/architecture/health-checks)", "term": "Requires" }, { "description": "[Availability](/records/lexicon/availability), [Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Traffic Distribution](/records/lexicon/traffic-distribution)", "term": "Enables" }, { "description": "[Session Affinity](/records/lexicon/session-affinity)", "term": "In tension with" }, { "description": "[Single Target Routing](/records/lexicon/single-target-routing)", "term": "Conflicts with" }, { "description": "[Competing Consumers](/records/architecture/competing-consumers), [Statelessness](/records/architecture/statelessness), [Read Replica](/records/architecture/read-replica), [Health Checks](/records/architecture/health-checks)", "term": "Referenced by" }, { "description": "[Load Balancing / Session Affinity](/records/tension/load-balancing-session-affinity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Target Routing](/records/lexicon/single-target-routing)", "term": "Violated by" }, { "description": "skewed instance utilization", "term": "Detected by" }, { "description": "request distribution, [latency](/records/architecture/latency)", "term": "Measured by" }, { "description": "[Externalize Session State](/records/lexicon/externalize-session-state)", "term": "Refactored by" }, { "description": "infrastructure config checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const endpoint = fooServers[0];\nendpoint.handle(request);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const endpoint = fooLoadBalancer.next({ key: request.fooId });\nendpoint.handle(request);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure config checks", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Multiple Targets](/records/lexicon/multiple-targets), [Health Checks](/records/architecture/health-checks), [Availability](/records/lexicon/availability), [Scalability](/records/architecture/scalability), [Traffic Distribution](/records/lexicon/traffic-distribution)", "term": "Depends on" }, { "description": "[Single Target Routing](/records/lexicon/single-target-routing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-load-balancing", "title": "Load Balancing" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: database, storage, messaging", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that splits a dataset across separate stores by a shard key, and routes each request to the shard that holds its key.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Partition Key](/records/lexicon/partition-key)", "term": "Requires" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Reinforces" }, { "description": "[Large Dataset Scaling](/records/lexicon/large-dataset-scaling)", "term": "Enables" }, { "description": "[Cross-Shard Queries](/records/lexicon/cross-shard-queries)", "term": "In tension with" }, { "description": "[Single Monolithic Store](/records/lexicon/single-monolithic-store)", "term": "Conflicts with" }, { "description": "[Sharding / Cross-Shard Queries](/records/tension/cross-shard-queries-sharding)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Monolithic Store](/records/lexicon/single-monolithic-store)", "term": "Violated by" }, { "description": "hotspot partitions, storage bottleneck", "term": "Detected by" }, { "description": "shard balance, query fan-out", "term": "Measured by" }, { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Refactored by" }, { "description": "data architecture review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await singleFooDatabase.find(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const shard = fooShardMap.resolve(id);\nconst foo = await shard.find(id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "data architecture review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Partition Key](/records/lexicon/partition-key), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Large Dataset Scaling](/records/lexicon/large-dataset-scaling)", "term": "Depends on" }, { "description": "[Single Monolithic Store](/records/lexicon/single-monolithic-store)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-sharding", "title": "Sharding" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data, workload, service", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing data or work into independent partitions by a key, so each can be processed in parallel.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Partition Strategy](/records/lexicon/partition-strategy)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Isolation](/records/architecture/isolation)", "term": "Reinforces" }, { "description": "[Parallelism](/records/architecture/parallelism)", "term": "Enables" }, { "description": "[Rebalancing Complexity](/records/lexicon/rebalancing-complexity)", "term": "In tension with" }, { "description": "[Global Shared State](/records/lexicon/global-shared-state)", "term": "Conflicts with" }, { "description": "[Partitioning / Rebalancing Complexity](/records/tension/partitioning-rebalancing-complexity)", "term": "Tensions" }, { "description": "[Parallelism](/records/architecture/parallelism): Partitioning divides data or work by a key, while parallelism runs the independent parts at the same time.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Monolithic Store](/records/lexicon/single-monolithic-store)", "term": "Violated by" }, { "description": "hotspot resource usage", "term": "Detected by" }, { "description": "partition balance", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const events = await fooLog.readAll();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const partition = hash(fooId) % partitionCount;\nconst events = await fooLog.readPartition(partition);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Partition Strategy](/records/lexicon/partition-strategy), [Scalability](/records/architecture/scalability), [Isolation](/records/architecture/isolation), [Parallelism](/records/architecture/parallelism)", "term": "Depends on" }, { "description": "[Global Shared State](/records/lexicon/global-shared-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-partitioning", "title": "Partitioning" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data access, computation, API", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that stores the result of an expensive read or computation under a key derived from every input it depends on, and serves it again while that key matches.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Invalidation Policy](/records/lexicon/invalidation-policy)", "term": "Requires" }, { "description": "[Latency Reduction](/records/lexicon/latency-reduction), [Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Reduced Load](/records/lexicon/reduced-load)", "term": "Enables" }, { "description": "[Consistency](/records/architecture/consistency), [Always-Fresh Reads](/records/lexicon/always-fresh-reads)", "term": "In tension with" }, { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)", "term": "Conflicts with" }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" }, { "description": "[Caching / Consistency](/records/tension/caching-consistency), [Caching / Always-Fresh Reads](/records/tension/always-fresh-reads-caching)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Repeated Stable Computation](/records/lexicon/repeated-stable-computation)", "term": "Violated by" }, { "description": "hot repeated reads, high latency calls", "term": "Detected by" }, { "description": "hit ratio, stale read rate", "term": "Measured by" }, { "description": "[Context-Keyed Cache](/records/lexicon/context-keyed-cache), [Cache Invalidation on Write](/records/lexicon/cache-invalidation-on-write)", "term": "Refactored by" }, { "description": "performance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function loadFoo(id: FooId) { return fooStore.find(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function loadFoo(id: FooId) {\n const key = fingerprint(id, await fooStore.versionOf(id));\n const cached = await fooCache.get(key);\n if (cached) return cached;\n const foo = await fooStore.find(id);\n if (foo) await fooCache.set(key, foo);\n return foo;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance tests", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Invalidation Policy](/records/lexicon/invalidation-policy), [Latency Reduction](/records/lexicon/latency-reduction), [Scalability](/records/architecture/scalability), [Reduced Load](/records/lexicon/reduced-load)", "term": "Depends on" }, { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-caching", "title": "Caching" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: service, process, handler", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a handler keeps no request state between calls, so any instance can serve any request.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Externalized State](/records/lexicon/externalized-state)", "term": "Requires" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Load Balancing](/records/architecture/load-balancing), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Enables" }, { "description": "[State Access Latency](/records/lexicon/state-access-latency)", "term": "In tension with" }, { "description": "[Instance Affinity](/records/lexicon/instance-affinity), [Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Conflicts with" }, { "description": "[Statelessness / State Access Latency](/records/tension/state-access-latency-statelessness)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Instance-Local State](/records/lexicon/instance-local-state)", "term": "Violated by" }, { "description": "mutable static/session-local state", "term": "Detected by" }, { "description": "state externalization coverage", "term": "Measured by" }, { "description": "[Externalize Session State](/records/lexicon/externalize-session-state), [Session Management](/records/architecture/session-management)", "term": "Refactored by" }, { "description": "architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooHandler {\n private currentUser?: User;\n handle(request: Request) {\n this.currentUser = request.user;\n return processFoo(request, this.currentUser);\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooHandler {\n handle(request: Request) {\n return processFoo(request, request.user);\n }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture tests", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Externalized State](/records/lexicon/externalized-state), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Resilience](/records/architecture/resilience), [Load Balancing](/records/architecture/load-balancing), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Depends on" }, { "description": "[Instance Affinity](/records/lexicon/instance-affinity), [Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-statelessness", "title": "Statelessness" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, service, algorithm", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of several tasks in progress over overlapping time, with their access to shared state coordinated.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Requires" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "Reinforces" }, { "description": "[Overlapping Work](/records/lexicon/overlapping-work)", "term": "Enables" }, { "description": "[Complexity](/records/lexicon/complexity)", "term": "In tension with" }, { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Conflicts with" }, { "description": "[Concurrency / Complexity](/records/tension/complexity-concurrency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Violated by" }, { "description": "data races, flaky concurrent tests", "term": "Detected by" }, { "description": "[throughput](/records/architecture/throughput), race count", "term": "Measured by" }, { "description": "[Apply Concurrency Control](/records/lexicon/apply-concurrency-control), [Make Immutable](/records/lexicon/make-immutable)", "term": "Refactored by" }, { "description": "race detectors, [tests](/records/lexicon/tests)", "term": "Enforced by" }, { "description": "concurrency", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "for (const foo of foos) await processFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await Promise.all(foos.map(foo => processFoo(foo)));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "race detectors, tests", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Concurrency Control](/records/architecture/concurrency-control), [Throughput](/records/architecture/throughput), [Overlapping Work](/records/lexicon/overlapping-work)", "term": "Depends on" }, { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-concurrency", "title": "Concurrency" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, processing, runtime", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for running independent units of work at the same time on several cores or workers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Independent Work Units](/records/lexicon/independent-work-units)", "term": "Requires" }, { "description": "[Throughput](/records/architecture/throughput), [Performance](/records/lexicon/performance)", "term": "Reinforces" }, { "description": "[Multi-Core Utilization](/records/lexicon/multi-core-utilization)", "term": "Enables" }, { "description": "[Coordination Overhead](/records/lexicon/coordination-overhead)", "term": "In tension with" }, { "description": "[Sequential Bottleneck](/records/lexicon/sequential-bottleneck)", "term": "Conflicts with" }, { "description": "[Causality](/records/architecture/causality), [Partitioning](/records/architecture/partitioning), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" }, { "description": "[Parallelism / Coordination Overhead](/records/tension/coordination-overhead-parallelism)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Sequential Bottleneck](/records/lexicon/sequential-bottleneck)", "term": "Violated by" }, { "description": "CPU bottlenecks with independent work", "term": "Detected by" }, { "description": "speedup, utilization", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "performance benchmarks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const results = foos.map(foo => cpuHeavyFoo(foo));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const results = await workerPool.map(foos, foo => cpuHeavyFoo(foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance benchmarks", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Independent Work Units](/records/lexicon/independent-work-units), [Throughput](/records/architecture/throughput), [Performance](/records/lexicon/performance), [Multi-Core Utilization](/records/lexicon/multi-core-utilization)", "term": "Depends on" }, { "description": "[Sequential Bottleneck](/records/lexicon/sequential-bottleneck)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-parallelism", "title": "Parallelism" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, pipeline, system", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which a system completes requests, messages or items, counted per unit of time.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Capacity Model](/records/lexicon/capacity-model)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Load Handling](/records/lexicon/load-handling)", "term": "Enables" }, { "description": "[Latency](/records/architecture/latency)", "term": "In tension with" }, { "description": "[Bottlenecks](/records/lexicon/bottlenecks)", "term": "Conflicts with" }, { "description": "[Event Ordering](/records/architecture/event-ordering), [PACELC Theorem](/records/architecture/pacelc-theorem), [Backpressure](/records/architecture/backpressure), [Code Review](/records/architecture/code-review), [Concurrency](/records/architecture/concurrency), [Parallelism](/records/architecture/parallelism), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in), [Isolation](/records/architecture/isolation)", "term": "Referenced by" }, { "description": "[Throughput / Latency](/records/tension/latency-throughput)", "term": "Tensions" }, { "description": "[Latency](/records/architecture/latency): Throughput counts completions per unit of time, while latency measures the time of one request.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Bottlenecks](/records/lexicon/bottlenecks)", "term": "Violated by" }, { "description": "load test failures", "term": "Detected by" }, { "description": "requests/messages/items per second", "term": "Measured by" }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis), [Parallelism](/records/architecture/parallelism), [Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Refactored by" }, { "description": "performance gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "for (const foo of foos) await fooStore.save(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for (const batch of chunk(foos, 500)) await fooStore.saveBatch(batch);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance gates", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Capacity Model](/records/lexicon/capacity-model), [Scalability](/records/architecture/scalability), [Load Handling](/records/lexicon/load-handling)", "term": "Depends on" }, { "description": "[Bottlenecks](/records/lexicon/bottlenecks)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-throughput", "title": "Throughput" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: API, service, user flow", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A measure of the time between a request and its response, usually reported at percentiles.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Time Budget](/records/lexicon/time-budget)", "term": "Requires" }, { "description": "[User Experience](/records/lexicon/user-experience), [Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Responsiveness](/records/lexicon/responsiveness)", "term": "Enables" }, { "description": "[Throughput/Batching](/records/lexicon/throughput-batching)", "term": "In tension with" }, { "description": "[Long Blocking Work](/records/lexicon/long-blocking-work)", "term": "Conflicts with" }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast), [CAP Theorem](/records/architecture/cap-theorem), [PACELC Theorem](/records/architecture/pacelc-theorem), [Consensus](/records/architecture/consensus), [Message Queue](/records/architecture/message-queue), [Throughput](/records/architecture/throughput), [CDN / Edge Caching](/records/architecture/cdn-edge-caching), [Queuing Theory](/records/architecture/queuing-theory), [Consistency](/records/architecture/consistency), [Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Referenced by" }, { "description": "[Latency / Throughput/Batching](/records/tension/latency-throughput-batching)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Long Blocking Work](/records/lexicon/long-blocking-work)", "term": "Violated by" }, { "description": "trace span delays", "term": "Detected by" }, { "description": "p50/p95/p99 latency", "term": "Measured by" }, { "description": "[Caching](/records/architecture/caching), [Introduce Async Event](/records/lexicon/introduce-async-event), [Add Index](/records/lexicon/add-index)", "term": "Refactored by" }, { "description": "SLO gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "async function renderFoo(id: FooId) {\n const foo = await fooStore.find(id);\n const bar = await barStore.find(foo.barId);\n const baz = await bazStore.find(foo.bazId);\n return render(foo, bar, baz);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function renderFoo(id: FooId) {\n const foo = await fooStore.find(id);\n const [bar, baz] = await Promise.all([\n barStore.find(foo.barId),\n bazStore.find(foo.bazId),\n ]);\n return render(foo, bar, baz);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "SLO gates", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Time Budget](/records/lexicon/time-budget), [User Experience](/records/lexicon/user-experience), [Performance Engineering](/records/architecture/performance-engineering), [Responsiveness](/records/lexicon/responsiveness)", "term": "Depends on" }, { "description": "[Long Blocking Work](/records/lexicon/long-blocking-work)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-latency", "title": "Latency" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: codebase, service, system", "Aliases: Evidence-Based Optimization", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of setting performance budgets, measuring against a representative workload and changing code only where a measurement points.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling), [Benchmarking](/records/architecture/benchmarking)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Resource Efficiency](/records/lexicon/resource-efficiency)", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "[Maintainability](/records/lexicon/maintainability)", "term": "In tension with" }, { "description": "[Guess-Based Optimization](/records/lexicon/guess-based-optimization)", "term": "Conflicts with" }, { "description": "[Scalability](/records/architecture/scalability), [Latency](/records/architecture/latency), [Optimization](/records/architecture/optimization), [Profiling](/records/architecture/profiling), [Benchmarking](/records/architecture/benchmarking), [Resource Utilization](/records/architecture/resource-utilization)", "term": "Referenced by" }, { "description": "[Performance Core](/records/algorithms/performance-core)", "term": "Contracts" }, { "description": "[Performance Engineering / Maintainability](/records/tension/maintainability-performance-engineering)", "term": "Tensions" }, { "description": "[Benchmarking](/records/architecture/benchmarking): Performance engineering is the practice that sets budgets and acts on measurements, while benchmarking is the controlled timing it measures with.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Guess-Based Optimization](/records/lexicon/guess-based-optimization)", "term": "Violated by" }, { "description": "performance changes lacking benchmark", "term": "Detected by" }, { "description": "benchmark trend, SLO compliance", "term": "Measured by" }, { "description": "[Profiling](/records/architecture/profiling), [Bottleneck Analysis](/records/architecture/bottleneck-analysis), [Benchmarking](/records/architecture/benchmarking)", "term": "Refactored by" }, { "description": "performance CI", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "optimizeFooCode();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const budget = { p95LatencyMs: 150, throughputPerSecond: 1000 } as const;\nconst profile = await measureFooWorkload(representativeLoad);\nconst change = optimize(profile.hotspot);\nassertPerformance(change, budget);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance CI", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Profiling](/records/architecture/profiling), [Benchmarking](/records/architecture/benchmarking), [Scalability](/records/architecture/scalability), [Resource Efficiency](/records/lexicon/resource-efficiency)", "term": "Depends on" }, { "description": "[Guess-Based Optimization](/records/lexicon/guess-based-optimization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-performance-engineering", "title": "Performance Engineering" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, data structure", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an algorithm and its data structures are chosen for how their cost grows with input size.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Complexity Awareness](/records/lexicon/complexity-awareness)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Efficient Processing](/records/lexicon/efficient-processing)", "term": "Enables" }, { "description": "[Implementation Simplicity](/records/lexicon/implementation-simplicity)", "term": "In tension with" }, { "description": "[Inefficient Algorithm Choice](/records/lexicon/inefficient-algorithm-choice), [N Plus One Query](/records/architecture/n-plus-one-query)", "term": "Conflicts with" }, { "description": "[Time Complexity](/records/architecture/time-complexity), [Big O Notation](/records/architecture/big-o-notation)", "term": "Referenced by" }, { "description": "[Algorithmic Efficiency / Implementation Simplicity](/records/tension/algorithmic-efficiency-implementation-simplicity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Inefficient Algorithm Choice](/records/lexicon/inefficient-algorithm-choice)", "term": "Violated by" }, { "description": "complexity analysis, benchmark slope", "term": "Detected by" }, { "description": "time/space complexity", "term": "Measured by" }, { "description": "[Replace Algorithm](/records/lexicon/replace-algorithm), [Add Index](/records/lexicon/add-index)", "term": "Refactored by" }, { "description": "[review](/records/lexicon/review), benchmarks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function hasFoo(foos: Foo[], id: FooId) {\n return foos.some(foo => foo.id === id);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function indexFoos(foos: readonly Foo[]) {\n return new Map(foos.map(foo => [foo.id, foo]));\n}\nconst hasFoo = (index: ReadonlyMap, id: FooId) => index.has(id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "review, benchmarks", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Complexity Awareness](/records/lexicon/complexity-awareness), [Scalability](/records/architecture/scalability), [Efficient Processing](/records/lexicon/efficient-processing)", "term": "Depends on" }, { "description": "[Inefficient Algorithm Choice](/records/lexicon/inefficient-algorithm-choice), [N Plus One Query](/records/architecture/n-plus-one-query)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-algorithmic-efficiency", "title": "Algorithmic Efficiency" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, function", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A measure of how an algorithm's running time grows as its input grows.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Input Size Model](/records/lexicon/input-size-model)", "term": "Requires" }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Reinforces" }, { "description": "[Scalability Analysis](/records/lexicon/scalability-analysis)", "term": "Enables" }, { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "In tension with" }, { "description": "[Unbounded Runtime Growth](/records/lexicon/unbounded-runtime-growth)", "term": "Conflicts with" }, { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Referenced by" }, { "description": "[Time Complexity / Space Complexity](/records/tension/space-complexity-time-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Inefficient Algorithm Choice](/records/lexicon/inefficient-algorithm-choice)", "term": "Violated by" }, { "description": "nested loops over large inputs, benchmark slope", "term": "Detected by" }, { "description": "Big O, runtime scaling", "term": "Measured by" }, { "description": "[Replace Algorithm](/records/lexicon/replace-algorithm), [Add Index](/records/lexicon/add-index), [Caching](/records/architecture/caching)", "term": "Refactored by" }, { "description": "benchmark thresholds", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function duplicateFooIds(foos: Foo[]) {\n return foos.filter((foo, index) => foos.findIndex(x => x.id === foo.id) !== index);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function duplicateFooIds(foos: readonly Foo[]) {\n const seen = new Set();\n return foos.filter(foo => seen.has(foo.id) || !seen.add(foo.id));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "benchmark thresholds", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Input Size Model](/records/lexicon/input-size-model), [Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Scalability Analysis](/records/lexicon/scalability-analysis)", "term": "Depends on" }, { "description": "[Unbounded Runtime Growth](/records/lexicon/unbounded-runtime-growth)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-time-complexity", "title": "Time Complexity" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, process", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A measure of how an algorithm's memory use grows as its input grows.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Memory Model](/records/lexicon/memory-model)", "term": "Requires" }, { "description": "[Resource Utilization](/records/architecture/resource-utilization)", "term": "Reinforces" }, { "description": "[Memory Scalability](/records/lexicon/memory-scalability)", "term": "Enables" }, { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "In tension with" }, { "description": "[Unbounded Memory Growth](/records/lexicon/unbounded-memory-growth)", "term": "Conflicts with" }, { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Referenced by" }, { "description": "[Space Complexity / Time Complexity](/records/tension/space-complexity-time-complexity)", "term": "Tensions" }, { "description": "[Resource Utilization](/records/architecture/resource-utilization): Space complexity is how an algorithm's memory grows with input, while resource utilization is how much provisioned capacity is in use now.", "term": "Distinct from" }, { "description": "[Time Complexity](/records/architecture/time-complexity): Space complexity measures memory growth, while time complexity measures running-time growth.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Memory Growth](/records/lexicon/unbounded-memory-growth)", "term": "Violated by" }, { "description": "memory profiling, [full materialization](/records/lexicon/full-materialization)", "term": "Detected by" }, { "description": "Big O space, peak memory", "term": "Measured by" }, { "description": "[Sequential Access](/records/architecture/sequential-access), [Iterator Pattern](/records/architecture/iterator-pattern), [Chunked Processing](/records/lexicon/chunked-processing)", "term": "Refactored by" }, { "description": "memory benchmarks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoos(stream: AsyncIterable) {\n return collectAll(stream).then(foos => foos.map(transformFoo));\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function* processFoos(stream: AsyncIterable) {\n for await (const foo of stream) yield transformFoo(foo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "memory benchmarks", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Memory Model](/records/lexicon/memory-model), [Resource Utilization](/records/architecture/resource-utilization), [Memory Scalability](/records/lexicon/memory-scalability)", "term": "Depends on" }, { "description": "[Unbounded Memory Growth](/records/lexicon/unbounded-memory-growth)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-space-complexity", "title": "Space Complexity" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A method for classifying an algorithm by the upper bound on how its cost grows with input size, ignoring constant factors.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Complexity Model](/records/lexicon/complexity-model)", "term": "Requires" }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Reinforces" }, { "description": "[Comparative Analysis](/records/lexicon/comparative-analysis)", "term": "Enables" }, { "description": "[Constant-Factor Practicality](/records/lexicon/constant-factor-practicality)", "term": "In tension with" }, { "description": "[Anecdotal Performance Claims](/records/lexicon/anecdotal-performance-claims)", "term": "Conflicts with" }, { "description": "[Big O Notation / Constant-Factor Practicality](/records/tension/big-o-notation-constant-factor-practicality)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Inefficient Algorithm Choice](/records/lexicon/inefficient-algorithm-choice)", "term": "Violated by" }, { "description": "missing complexity note for critical algorithm", "term": "Detected by" }, { "description": "asymptotic classification", "term": "Measured by" }, { "description": "[Replace Algorithm](/records/lexicon/replace-algorithm)", "term": "Refactored by" }, { "description": "review checklist", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function pairFoosWithBars(foos: Foo[], bars: Bar[]) {\n return foos.flatMap(foo => bars.filter(bar => bar.fooId === foo.id).map(bar => [foo, bar]));\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function pairFoosWithBars(foos: readonly Foo[], bars: readonly Bar[]) {\n const barsByFoo = groupBy(bars, bar => bar.fooId);\n return foos.flatMap(foo => (barsByFoo.get(foo.id) ?? []).map(bar => [foo, bar]));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "review checklist", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Complexity Model](/records/lexicon/complexity-model), [Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Comparative Analysis](/records/lexicon/comparative-analysis)", "term": "Depends on" }, { "description": "[Anecdotal Performance Claims](/records/lexicon/anecdotal-performance-claims)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-big-o-notation", "title": "Big O Notation" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: code, database, system", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of changing code or configuration to reduce the cost of a bottleneck that a measurement has located.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling), [Bottleneck Evidence](/records/lexicon/bottleneck-evidence)", "term": "Requires" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Resource Efficiency](/records/lexicon/resource-efficiency)", "term": "Enables" }, { "description": "[Readability/Maintainability](/records/lexicon/readability-maintainability)", "term": "In tension with" }, { "description": "[Premature Optimization](/records/lexicon/premature-optimization)", "term": "Conflicts with" }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation), [Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Referenced by" }, { "description": "[Optimization / Readability/Maintainability](/records/tension/optimization-readability-maintainability)", "term": "Tensions" }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis): Optimization changes the code at a bottleneck, while bottleneck analysis finds where it is.", "term": "Distinct from" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering): Optimization is one change at a located bottleneck, while performance engineering is the whole practice of budgets, measurement and change.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Premature Optimization](/records/lexicon/premature-optimization)", "term": "Violated by" }, { "description": "complex code without performance evidence", "term": "Detected by" }, { "description": "benchmark delta, SLO improvement", "term": "Measured by" }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis), [Cleanup / Simplification](/records/lexicon/cleanup-simplification)", "term": "Refactored by" }, { "description": "benchmark review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooCache = new Map();\nfunction loadFoo(id: FooId) { return fooCache.get(id) ?? expensiveLoad(id); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const profile = profiler.measure(\"foo.load\", representativeFooIds);\nif (profile.hotspot === \"foo-store-read\") {\n enableBoundedFooCache({ maxEntries: 10_000, keyBy: fooVersionFingerprint });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "benchmark review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Profiling](/records/architecture/profiling), [Bottleneck Evidence](/records/lexicon/bottleneck-evidence), [Performance Engineering](/records/architecture/performance-engineering), [Resource Efficiency](/records/lexicon/resource-efficiency)", "term": "Depends on" }, { "description": "[Premature Optimization](/records/lexicon/premature-optimization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-optimization", "title": "Optimization" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: runtime, code path", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for measuring where a running program spends its time and memory under a representative workload.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Representative Workload](/records/lexicon/representative-workload)", "term": "Requires" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Bottleneck Detection](/records/lexicon/bottleneck-detection)", "term": "Enables" }, { "description": "[Measurement Overhead](/records/lexicon/measurement-overhead)", "term": "In tension with" }, { "description": "[Guesswork](/records/lexicon/guesswork)", "term": "Conflicts with" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering), [Optimization](/records/architecture/optimization), [Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Referenced by" }, { "description": "[Profiling / Measurement Overhead](/records/tension/measurement-overhead-profiling)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Guesswork](/records/lexicon/guesswork)", "term": "Violated by" }, { "description": "missing profile evidence", "term": "Detected by" }, { "description": "hotspot attribution", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "performance review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "rewriteFooParserForSpeed();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const profile = await profiler.capture(() => parseFooBatch(batch));\nconst hotspot = profile.topFrame();\noptimizeFooFrame(hotspot);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Representative Workload](/records/lexicon/representative-workload), [Performance Engineering](/records/architecture/performance-engineering), [Bottleneck Detection](/records/lexicon/bottleneck-detection)", "term": "Depends on" }, { "description": "[Guesswork](/records/lexicon/guesswork)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-profiling", "title": "Profiling" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, service, system", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of timing a fixed workload repeatedly in a controlled environment, so results can be compared across changes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Repeatable Test Environment](/records/lexicon/repeatable-test-environment)", "term": "Requires" }, { "description": "[Reproducibility](/records/architecture/reproducibility), [Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Regression Detection](/records/lexicon/regression-detection)", "term": "Enables" }, { "description": "[Environment Drift](/records/lexicon/environment-drift)", "term": "In tension with" }, { "description": "[Anecdotal Timing](/records/lexicon/anecdotal-timing)", "term": "Conflicts with" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Referenced by" }, { "description": "[Benchmarking / Environment Drift](/records/tension/benchmarking-environment-drift)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Anecdotal Performance Claims](/records/lexicon/anecdotal-performance-claims)", "term": "Violated by" }, { "description": "missing benchmark for perf-sensitive changes", "term": "Detected by" }, { "description": "benchmark score/trend", "term": "Measured by" }, { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Refactored by" }, { "description": "benchmark CI", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const start = clock.now();\nrunFoo();\nreport(clock.now() - start);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "benchmark(\"foo.parse\", {\n warmup: 100,\n iterations: 10_000,\n run: () => parseFoo(fixture),\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "benchmark CI", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Repeatable Test Environment](/records/lexicon/repeatable-test-environment), [Reproducibility](/records/architecture/reproducibility), [Performance Engineering](/records/architecture/performance-engineering), [Regression Detection](/records/lexicon/regression-detection)", "term": "Depends on" }, { "description": "[Anecdotal Timing](/records/lexicon/anecdotal-timing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-benchmarking", "title": "Benchmarking" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: code path, system", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of finding the stage that limits a system's overall throughput or latency, from traces and profiles.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling), [Metrics](/records/lexicon/metrics)", "term": "Requires" }, { "description": "[Optimization](/records/architecture/optimization)", "term": "Reinforces" }, { "description": "[Targeted Improvement](/records/lexicon/targeted-improvement)", "term": "Enables" }, { "description": "[Distributed Complexity](/records/lexicon/distributed-complexity)", "term": "In tension with" }, { "description": "[Local Micro-Optimization](/records/lexicon/local-micro-optimization)", "term": "Conflicts with" }, { "description": "[Bottleneck Analysis / Distributed Complexity](/records/tension/bottleneck-analysis-distributed-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Local Micro-Optimization](/records/lexicon/local-micro-optimization)", "term": "Violated by" }, { "description": "performance work without hotspot evidence", "term": "Detected by" }, { "description": "bottleneck contribution percentage", "term": "Measured by" }, { "description": "[Parallelism](/records/architecture/parallelism), [Caching](/records/architecture/caching)", "term": "Refactored by" }, { "description": "performance review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "addMoreFooWorkers();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const trace = await measureFooPipeline();\nconst bottleneck = trace.stages.sort((a, b) => b.waitMs - a.waitMs)[0];\nremoveBottleneck(bottleneck);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Profiling](/records/architecture/profiling), [Metrics](/records/lexicon/metrics), [Optimization](/records/architecture/optimization), [Targeted Improvement](/records/lexicon/targeted-improvement)", "term": "Depends on" }, { "description": "[Local Micro-Optimization](/records/lexicon/local-micro-optimization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-bottleneck-analysis", "title": "Bottleneck Analysis" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: CPU, memory, IO, network", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A measure of how much of the provisioned CPU, memory, I/O and network capacity is in use.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Requires" }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Reinforces" }, { "description": "[Capacity Planning](/records/lexicon/capacity-planning)", "term": "Enables" }, { "description": "[Over-Provisioning](/records/lexicon/over-provisioning)", "term": "In tension with" }, { "description": "[Resource Waste/Saturation](/records/lexicon/resource-waste-saturation)", "term": "Conflicts with" }, { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern), [Space Complexity](/records/architecture/space-complexity)", "term": "Referenced by" }, { "description": "[Resource Utilization / Over-Provisioning](/records/tension/over-provisioning-resource-utilization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Resource Waste/Saturation](/records/lexicon/resource-waste-saturation)", "term": "Violated by" }, { "description": "monitoring metrics", "term": "Detected by" }, { "description": "CPU/memory/IO/network utilization", "term": "Measured by" }, { "description": "[Profiling](/records/architecture/profiling), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Externalize Configuration](/records/lexicon/externalize-configuration)", "term": "Refactored by" }, { "description": "SLO/capacity policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployFoo({ cpu: 16, memoryGb: 64 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const sizing = rightSizeFoo({\n cpuP95: metrics.cpu(\"foo\", \"p95\"),\n memoryP95: metrics.memory(\"foo\", \"p95\"),\n headroom: 0.25,\n});\ndeployFoo(sizing);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "SLO/capacity policy", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Monitoring](/records/architecture/monitoring), [Performance Engineering](/records/architecture/performance-engineering), [Capacity Planning](/records/lexicon/capacity-planning)", "term": "Depends on" }, { "description": "[Resource Waste/Saturation](/records/lexicon/resource-waste-saturation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-resource-utilization", "title": "Resource Utilization" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: public APIs", "Scope: API, service, queue", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that caps how many requests a caller can make in a time window and rejects the excess.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Quota Policy](/records/lexicon/quota-policy)", "term": "Requires" }, { "description": "[Backpressure](/records/architecture/backpressure), [Security](/records/lexicon/security)", "term": "Reinforces" }, { "description": "[Abuse/Overload Protection](/records/lexicon/abuse-overload-protection)", "term": "Enables" }, { "description": "[User Experience](/records/lexicon/user-experience)", "term": "In tension with" }, { "description": "[Unbounded Access](/records/lexicon/unbounded-access)", "term": "Conflicts with" }, { "description": "[Rate Limiting / User Experience](/records/tension/rate-limiting-user-experience)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Access](/records/lexicon/unbounded-access)", "term": "Violated by" }, { "description": "missing rate limiter on public/expensive endpoints", "term": "Detected by" }, { "description": "limit hit rate, overload incidents", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "API gateway/policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo\", createFoo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.post(\"/foo\", rateLimit({\n key: request => request.identity.id,\n limit: 100,\n windowMs: 60_000,\n}), createFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API gateway/policy", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Quota Policy](/records/lexicon/quota-policy), [Backpressure](/records/architecture/backpressure), [Security](/records/lexicon/security), [Abuse/Overload Protection](/records/lexicon/abuse-overload-protection)", "term": "Depends on" }, { "description": "[Unbounded Access](/records/lexicon/unbounded-access)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-rate-limiting", "title": "Rate Limiting" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, process, stream", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a process handles its input with bounded memory, by streaming or chunking instead of loading it whole.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Space Complexity Awareness](/records/lexicon/space-complexity-awareness)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Reinforces" }, { "description": "[Large Input Handling](/records/lexicon/large-input-handling)", "term": "Enables" }, { "description": "[CPU Cost](/records/lexicon/cpu-cost)", "term": "In tension with" }, { "description": "[Full Materialization](/records/lexicon/full-materialization)", "term": "Conflicts with" }, { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern), [Single-Pass Processing](/records/architecture/single-pass-processing), [Lazy Evaluation](/records/architecture/lazy-evaluation), [Sequential Access](/records/architecture/sequential-access)", "term": "Referenced by" }, { "description": "[Memory Efficiency / CPU Cost](/records/tension/cpu-cost-memory-efficiency)", "term": "Tensions" }, { "description": "[CPU Cost](/records/lexicon/cpu-cost): Memory efficiency bounds the memory a process uses, while CPU cost is the processor time that streaming or chunking may add.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Memory Growth](/records/lexicon/unbounded-memory-growth)", "term": "Violated by" }, { "description": "memory profile spikes", "term": "Detected by" }, { "description": "peak memory, allocation rate", "term": "Measured by" }, { "description": "[Event Stream](/records/architecture/event-stream), [Chunked Processing](/records/lexicon/chunked-processing), [Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Refactored by" }, { "description": "memory benchmarks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const copies = foos.map(foo => structuredClone(foo));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function* fooViews(foos: readonly Foo[]) {\n for (const foo of foos) yield { id: foo.id, name: foo.name };\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "memory benchmarks", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Space Complexity Awareness](/records/lexicon/space-complexity-awareness), [Scalability](/records/architecture/scalability), [Large Input Handling](/records/lexicon/large-input-handling)", "term": "Depends on" }, { "description": "[Full Materialization](/records/lexicon/full-materialization)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-memory-efficiency", "title": "Memory Efficiency" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, infrastructure, latency", "Aliases: Content Delivery Network", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that serves cacheable content from servers near the requester, keyed by a fingerprint of the content.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Cacheable Content](/records/lexicon/cacheable-content)", "term": "Requires" }, { "description": "[Caching](/records/architecture/caching), [Latency](/records/architecture/latency)", "term": "Reinforces" }, { "description": "[Origin Offload](/records/lexicon/origin-offload), [Geographically-Local Delivery](/records/lexicon/geographically-local-delivery)", "term": "Enables" }, { "description": "[Cache Invalidation](/records/lexicon/cache-invalidation)", "term": "In tension with" }, { "description": "[Origin-Only Serving](/records/lexicon/origin-only-serving)", "term": "Conflicts with" }, { "description": "[CDN / Edge Caching / Cache Invalidation](/records/tension/cache-invalidation-cdn-edge-caching)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Origin-Only Serving](/records/lexicon/origin-only-serving)", "term": "Violated by" }, { "description": "static assets served from origin per request", "term": "Detected by" }, { "description": "origin request rate / cache hit ratio", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "performance review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/foo/:id/avatar\", serveFooAvatarFromOrigin);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.get(\"/foo/:id/avatar\",\n edgeCache({ immutable: true, key: request => avatarFingerprint(request.params.id) }),\n serveFooAvatarFromOrigin,\n);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Cacheable Content](/records/lexicon/cacheable-content), [Caching](/records/architecture/caching), [Latency](/records/architecture/latency), [Origin Offload](/records/lexicon/origin-offload), [Geographically-Local Delivery](/records/lexicon/geographically-local-delivery)", "term": "Depends on" }, { "description": "[Origin-Only Serving](/records/lexicon/origin-only-serving)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-cdn-edge-caching", "title": "CDN / Edge Caching" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, database, scalability", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for routing read queries to replicated copies of a database, so the primary handles only writes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Replication](/records/architecture/replication)", "term": "Requires" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing)", "term": "Reinforces" }, { "description": "[Read Traffic Offload](/records/lexicon/read-traffic-offload)", "term": "Enables" }, { "description": "[Read-Your-Writes Consistency](/records/lexicon/read-your-writes-consistency)", "term": "In tension with" }, { "description": "[Single-Primary Read Contention](/records/lexicon/single-primary-read-contention)", "term": "Conflicts with" }, { "description": "[Read Replica / Read-Your-Writes Consistency](/records/tension/read-replica-read-your-writes-consistency)", "term": "Tensions" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling): A read replica scales database reads by copying data, while horizontal scaling adds stateless service instances behind a load balancer.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single-Primary Read Contention](/records/lexicon/single-primary-read-contention)", "term": "Violated by" }, { "description": "read load saturating the write primary", "term": "Detected by" }, { "description": "primary read/write contention ratio", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "database design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await primaryDb.query(fooQuery);\nawait primaryDb.write(fooCommand);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await replicaRouter.read(fooQuery);\nawait primaryDb.write(fooCommand);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "database design review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Replication](/records/architecture/replication), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing), [Read Traffic Offload](/records/lexicon/read-traffic-offload)", "term": "Depends on" }, { "description": "[Single-Primary Read Contention](/records/lexicon/single-primary-read-contention)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-read-replica", "title": "Read Replica" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/architecture-category/scalability-performance-optimization)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: performance, capacity, system", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of a system as queues with arrival and service rates, used to predict waiting time and size capacity.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Arrival and Service Rates](/records/lexicon/arrival-and-service-rates)", "term": "Requires" }, { "description": "[Capacity Planning](/records/lexicon/capacity-planning), [Latency](/records/architecture/latency)", "term": "Reinforces" }, { "description": "[Wait-Time Prediction](/records/lexicon/wait-time-prediction), [Utilization-Based Sizing](/records/lexicon/utilization-based-sizing)", "term": "Enables" }, { "description": "[Model Assumptions](/records/lexicon/model-assumptions)", "term": "In tension with" }, { "description": "[Guess-Based Capacity](/records/lexicon/guess-based-capacity)", "term": "Conflicts with" }, { "description": "[Queuing Theory](/records/algorithms/queuing-theory)", "term": "Contracts" }, { "description": "[Queuing Theory / Model Assumptions](/records/tension/model-assumptions-queuing-theory)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Guess-Based Capacity](/records/lexicon/guess-based-capacity)", "term": "Violated by" }, { "description": "latency collapsing as utilization approaches saturation", "term": "Detected by" }, { "description": "predicted vs actual queue depth and wait time", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "capacity review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const workers = 4;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const rho = arrivalRate / (workers * serviceRate);\nif (rho >= 1) throw new Error(\"unstable queue: utilization >= 1\");\nconst avgWaitMs = mm1WaitTime({ arrivalRate, serviceRate, servers: workers });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "capacity review", "term": "Checked by" }, { "description": "Every performance-sensitive path, resource and scaling policy under a declared workload", "term": "Population" }, { "description": "A verdict stands for the measured workload and build, and goes stale when either changes", "term": "Freshness" }, { "description": "The load test, benchmark or SLO gate fails the change that breaks its budget", "term": "Refusal" }, { "description": "Profiles, benchmark results, load-test metrics and production telemetry measured against their budgets", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared budget, which every measurement is compared against", "term": "Authoritative side" }, { "description": "[Arrival and Service Rates](/records/lexicon/arrival-and-service-rates), [Capacity Planning](/records/lexicon/capacity-planning), [Latency](/records/architecture/latency), [Wait-Time Prediction](/records/lexicon/wait-time-prediction), [Utilization-Based Sizing](/records/lexicon/utilization-based-sizing)", "term": "Depends on" }, { "description": "[Guess-Based Capacity](/records/lexicon/guess-based-capacity)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-queuing-theory", "title": "Queuing Theory" } ], "title": "Scalability / Performance / Optimization" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_streaming_architecture[\"Streaming Architecture\"]\n n_single_pass_processing[\"Single-Pass Processing\"]\n n_pipeline_architecture[\"Pipeline Architecture\"]\n n_lazy_evaluation[\"Lazy Evaluation\"]\n n_sequential_access[\"Sequential Access\"]\n n_forward_only_processing[\"Forward-Only Processing\"]\n n_dataflow_architecture[\"Dataflow Architecture\"]\n n_stateless_processing[\"Stateless Processing\"]\n n_windowing[\"Windowing\"]\n n_fan_out_fan_in[\"Fan-out/Fan-in\"]\n n_batch_vs_stream[\"Batch-vs-Stream\"]\n n_streaming_architecture --> n_single_pass_processing\n n_forward_only_processing --> n_single_pass_processing\n n_dataflow_architecture --> n_pipeline_architecture\n n_windowing --> n_streaming_architecture" } ], "icon": "bi-collection", "id": "architecture-category-streaming-pipeline-dataflow-processing", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data processing, integration", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of processing data record by record as it arrives, with backpressure, instead of collecting it first.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream), [Backpressure](/records/architecture/backpressure)", "term": "Requires" }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Reinforces" }, { "description": "[Continuous Processing](/records/lexicon/continuous-processing)", "term": "Enables" }, { "description": "[Ordering/State](/records/lexicon/ordering-state), [Batch-Only Processing](/records/lexicon/batch-only-processing)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Event Stream](/records/architecture/event-stream), [Windowing](/records/architecture/windowing)", "term": "Referenced by" }, { "description": "[Streaming Architecture / Ordering/State](/records/tension/ordering-state-streaming-architecture), [Streaming Architecture / Batch-Only Processing](/records/tension/batch-only-processing-streaming-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Full Materialization](/records/lexicon/full-materialization)", "term": "Violated by" }, { "description": "unbounded collection over stream source", "term": "Detected by" }, { "description": "lag, [throughput](/records/architecture/throughput), memory usage", "term": "Measured by" }, { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Refactored by" }, { "description": "load/memory tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foos = await source.readAll();\nconst results = foos.map(transformFoo);\nawait sink.writeAll(results);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for await (const foo of source.stream()) {\n await sink.write(transformFoo(foo));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "load/memory tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Event Stream](/records/architecture/event-stream), [Backpressure](/records/architecture/backpressure), [Single-Pass Processing](/records/architecture/single-pass-processing), [Continuous Processing](/records/lexicon/continuous-processing)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-streaming-architecture", "title": "Streaming Architecture" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: algorithm, stream, parser", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that large input is read once, with every result it feeds computed in that one pass.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Forward-Only State Model](/records/lexicon/forward-only-state-model)", "term": "Requires" }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Reinforces" }, { "description": "[Large Input Handling](/records/lexicon/large-input-handling)", "term": "Enables" }, { "description": "[Global Optimization](/records/lexicon/global-optimization), [Multi-Pass Full Materialization](/records/lexicon/multi-pass-full-materialization)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture), [Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Referenced by" }, { "description": "[Single-Pass Processing / Global Optimization](/records/tension/global-optimization-single-pass-processing), [Single-Pass Processing / Multi-Pass Full Materialization](/records/tension/multi-pass-full-materialization-single-pass-processing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Repeated Full Scan](/records/lexicon/repeated-full-scan)", "term": "Violated by" }, { "description": "multiple loops/materializations over same large input", "term": "Detected by" }, { "description": "pass count, memory use", "term": "Measured by" }, { "description": "[Fuse Passes](/records/lexicon/fuse-passes), [Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Refactored by" }, { "description": "performance review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const names = foos.map(foo => foo.name);\nconst active = foos.filter(foo => foo.active);\nconst total = foos.reduce((sum, foo) => sum + foo.count, 0);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const names: string[] = [];\nconst active: Foo[] = [];\nlet total = 0;\nfor (const foo of foos) {\n names.push(foo.name);\n if (foo.active) active.push(foo);\n total += foo.count;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance review", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Forward-Only State Model](/records/lexicon/forward-only-state-model), [Memory Efficiency](/records/architecture/memory-efficiency), [Large Input Handling](/records/lexicon/large-input-handling)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-single-pass-processing", "title": "Single-Pass Processing" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: processing, dataflow, build", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that splits processing into ordered stages, each with a declared input and output contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stage Contracts](/records/lexicon/stage-contracts)", "term": "Requires" }, { "description": "[Composability](/records/architecture/composability), [Streaming](/records/lexicon/streaming)", "term": "Reinforces" }, { "description": "[Stepwise Transformation](/records/lexicon/stepwise-transformation)", "term": "Enables" }, { "description": "[Error Propagation/Debugging](/records/lexicon/error-propagation-debugging)", "term": "In tension with" }, { "description": "[Monolithic Processing Function](/records/lexicon/monolithic-processing-function)", "term": "Conflicts with" }, { "description": "[Composability](/records/architecture/composability), [Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" }, { "description": "[Pipeline Architecture / Error Propagation/Debugging](/records/tension/error-propagation-debugging-pipeline-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Monolithic Processing Function](/records/lexicon/monolithic-processing-function)", "term": "Violated by" }, { "description": "long procedural transformation chain", "term": "Detected by" }, { "description": "stage cohesion, stage contract coverage", "term": "Measured by" }, { "description": "[Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "pipeline tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(raw: string) {\n const parsed = JSON.parse(raw);\n const validated = validateFoo(parsed);\n const normalized = normalizeFoo(validated);\n return saveFoo(normalized);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooPipeline = pipeline(\n parseJson,\n validateWith(FooSchema),\n normalizeFoo,\n saveFoo,\n);\nfooPipeline.run(raw);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "pipeline tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Stage Contracts](/records/lexicon/stage-contracts), [Composability](/records/architecture/composability), [Streaming](/records/lexicon/streaming), [Stepwise Transformation](/records/lexicon/stepwise-transformation)", "term": "Depends on" }, { "description": "[Monolithic Processing Function](/records/lexicon/monolithic-processing-function)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pipeline-architecture", "title": "Pipeline Architecture" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: computation, collection, stream", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which a value is computed only when something consumes it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Deferred Execution Semantics](/records/lexicon/deferred-execution-semantics)", "term": "Requires" }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Reinforces" }, { "description": "[Avoiding Unneeded Work](/records/lexicon/avoiding-unneeded-work)", "term": "Enables" }, { "description": "[Debuggability/Resource Lifetime](/records/lexicon/debuggability-resource-lifetime), [Eager Full Materialization](/records/lexicon/eager-full-materialization)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Lazy Evaluation / Debuggability/Resource Lifetime](/records/tension/debuggability-resource-lifetime-lazy-evaluation), [Lazy Evaluation / Eager Full Materialization](/records/tension/eager-full-materialization-lazy-evaluation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Full Materialization](/records/lexicon/full-materialization)", "term": "Violated by" }, { "description": "eager loading of large unused data", "term": "Detected by" }, { "description": "avoided work, memory reduction", "term": "Measured by" }, { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Refactored by" }, { "description": "performance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const normalized = millionFoos.map(normalizeFoo);\nconst active = normalized.filter(foo => foo.active);\nconst firstTen = active.slice(0, 10);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const firstTen = sequence(millionFoos)\n .map(normalizeFoo)\n .filter(foo => foo.active)\n .take(10)\n .toArray();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Deferred Execution Semantics](/records/lexicon/deferred-execution-semantics), [Memory Efficiency](/records/architecture/memory-efficiency), [Avoiding Unneeded Work](/records/lexicon/avoiding-unneeded-work)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-lazy-evaluation", "title": "Lazy Evaluation" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: file, stream, iterator", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that reads a source in its stored order through a cursor or scan, instead of looking records up one by one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ordered Read Model](/records/lexicon/ordered-read-model)", "term": "Requires" }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Reinforces" }, { "description": "[Large Data Processing](/records/lexicon/large-data-processing)", "term": "Enables" }, { "description": "[Lookup Performance](/records/lexicon/lookup-performance), [Random Access Requirement](/records/lexicon/random-access-requirement)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Sequential Access / Lookup Performance](/records/tension/lookup-performance-sequential-access), [Sequential Access / Random Access Requirement](/records/tension/random-access-requirement-sequential-access)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Random Access over a Stream](/records/lexicon/random-access-over-a-stream)", "term": "Violated by" }, { "description": "seek/index assumptions on sequential source", "term": "Detected by" }, { "description": "access pattern cost", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "performance tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "for (const id of fooIds) await fooStore.randomRead(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for await (const foo of fooStore.scan({ orderBy: \"id\" })) {\n processFoo(foo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "performance tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Ordered Read Model](/records/lexicon/ordered-read-model), [Memory Efficiency](/records/architecture/memory-efficiency), [Large Data Processing](/records/lexicon/large-data-processing)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-sequential-access", "title": "Sequential Access" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: stream, parser, iterator", "Aliases: No Backtracking Requirement", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a stream is read once in order, keeping only rolling state, so no decision ever needs to revisit earlier input.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Reinforces" }, { "description": "[Streaming Parsers](/records/lexicon/streaming-parsers)", "term": "Enables" }, { "description": "[Complex Grammar/Global State](/records/lexicon/complex-grammar-global-state), [Backtracking Algorithm](/records/lexicon/backtracking-algorithm)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Forward-Only Processing / Complex Grammar/Global State](/records/tension/complex-grammar-global-state-forward-only-processing), [Forward-Only Processing / Backtracking Algorithm](/records/tension/backtracking-algorithm-forward-only-processing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Look-Back Buffering](/records/lexicon/look-back-buffering)", "term": "Violated by" }, { "description": "buffering full stream to look back", "term": "Detected by" }, { "description": "buffer size, pass count", "term": "Measured by" }, { "description": "[Windowing](/records/architecture/windowing), [Tolerant Reader](/records/lexicon/tolerant-reader)", "term": "Refactored by" }, { "description": "memory tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const cursor = fooStream.cursor();\ncursor.next();\ncursor.previous();\ncursor.seek(0);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for await (const foo of fooStream) {\n await processFoo(foo);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "memory tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing), [Streaming Parsers](/records/lexicon/streaming-parsers)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-forward-only-processing", "title": "Forward-Only Processing" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: processing, workflow, stream", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of arranging processing as a graph of stages connected by explicit data edges, where a stage runs when its inputs arrive.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Data Dependencies](/records/lexicon/data-dependencies), [Stages](/records/lexicon/stages)", "term": "Requires" }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Reinforces" }, { "description": "[Parallel/Stream Processing](/records/lexicon/parallel-stream-processing)", "term": "Enables" }, { "description": "[State Coordination](/records/lexicon/state-coordination)", "term": "In tension with" }, { "description": "[Control-Flow-Centric Monolith](/records/lexicon/control-flow-centric-monolith)", "term": "Conflicts with" }, { "description": "[Dataflow Architecture / State Coordination](/records/tension/dataflow-architecture-state-coordination)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "implicit shared state in pipeline", "term": "Detected by" }, { "description": "data dependency clarity", "term": "Measured by" }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Refactored by" }, { "description": "pipeline contracts", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "controller.runFoo();\ncontroller.runBar();\ncontroller.runBaz();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const graph = dataflow()\n .source(\"foo\", fooSource)\n .map(\"bar\", \"foo\", toBar)\n .map(\"baz\", \"bar\", toBaz)\n .sink(\"output\", \"baz\", bazSink);\nawait graph.run();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "pipeline contracts", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Data Dependencies](/records/lexicon/data-dependencies), [Stages](/records/lexicon/stages), [Pipeline Architecture](/records/architecture/pipeline-architecture), [Parallel/Stream Processing](/records/lexicon/parallel-stream-processing)", "term": "Depends on" }, { "description": "[Control-Flow-Centric Monolith](/records/lexicon/control-flow-centric-monolith)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dataflow-architecture", "title": "Dataflow Architecture" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, stream processor, service", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a processor derives each result only from its input and explicitly passed context.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Inputs](/records/lexicon/explicit-inputs), [No Hidden State](/records/lexicon/no-hidden-state)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Parallel Processing](/records/lexicon/parallel-processing)", "term": "Enables" }, { "description": "[Stateful Business Rules](/records/lexicon/stateful-business-rules)", "term": "In tension with" }, { "description": "[Stateful Hidden Accumulation](/records/lexicon/stateful-hidden-accumulation)", "term": "Conflicts with" }, { "description": "[Stateless Processing / Stateful Business Rules](/records/tension/stateful-business-rules-stateless-processing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Stateful Hidden Accumulation](/records/lexicon/stateful-hidden-accumulation)", "term": "Violated by" }, { "description": "mutable state across records/requests", "term": "Detected by" }, { "description": "stateful operator count", "term": "Measured by" }, { "description": "[Externalize Session State](/records/lexicon/externalize-session-state), [Pass Context Explicitly](/records/lexicon/pass-context-explicitly)", "term": "Refactored by" }, { "description": "[code review](/records/architecture/code-review), [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooProcessor {\n private previous?: Foo;\n process(foo: Foo) {\n const result = merge(this.previous, foo);\n this.previous = foo;\n return result;\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function processFoo(foo: Foo, context: Readonly): FooResult {\n return deriveFooResult(foo, context);\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "code review, tests", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Explicit Inputs](/records/lexicon/explicit-inputs), [No Hidden State](/records/lexicon/no-hidden-state), [Scalability](/records/architecture/scalability), [Testability](/records/architecture/testability), [Parallel Processing](/records/lexicon/parallel-processing)", "term": "Depends on" }, { "description": "[Stateful Hidden Accumulation](/records/lexicon/stateful-hidden-accumulation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-stateless-processing", "title": "Stateless Processing" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data processing, streaming, aggregation", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that groups an unbounded stream into bounded windows of event time and aggregates each window separately.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Event Time](/records/lexicon/event-time)", "term": "Requires" }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture), [Bounded State](/records/lexicon/bounded-state)", "term": "Reinforces" }, { "description": "[Bounded Aggregation over Unbounded Streams](/records/lexicon/bounded-aggregation-over-unbounded-streams)", "term": "Enables" }, { "description": "[Late-Data Handling](/records/lexicon/late-data-handling)", "term": "In tension with" }, { "description": "[Unbounded Accumulation](/records/lexicon/unbounded-accumulation)", "term": "Conflicts with" }, { "description": "[Windowing / Late-Data Handling](/records/tension/late-data-handling-windowing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unbounded Accumulation](/records/lexicon/unbounded-accumulation)", "term": "Violated by" }, { "description": "unbounded accumulator over a stream", "term": "Detected by" }, { "description": "aggregation state growth rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "streaming design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const total = allFooEvents.reduce((sum, event) => sum + event.value, 0);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "for await (const window of fooStream.tumbling({ seconds: 60 })) {\n emit(window.start, window.events.reduce((sum, event) => sum + event.value, 0));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "streaming design review", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Event Time](/records/lexicon/event-time), [Streaming Architecture](/records/architecture/streaming-architecture), [Bounded State](/records/lexicon/bounded-state), [Bounded Aggregation over Unbounded Streams](/records/lexicon/bounded-aggregation-over-unbounded-streams)", "term": "Depends on" }, { "description": "[Unbounded Accumulation](/records/lexicon/unbounded-accumulation)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-windowing", "title": "Windowing" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data processing, parallelism, pipeline", "Aliases: Upward Reduction", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that splits work into independent parts processed in parallel, then merges their results.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Independent Work Units](/records/lexicon/independent-work-units)", "term": "Requires" }, { "description": "[Parallelism](/records/architecture/parallelism), [Throughput](/records/architecture/throughput)", "term": "Reinforces" }, { "description": "[Parallel Branch Processing](/records/lexicon/parallel-branch-processing), [Result Aggregation](/records/lexicon/result-aggregation)", "term": "Enables" }, { "description": "[Coordination Overhead](/records/lexicon/coordination-overhead), [Serial Item Processing](/records/lexicon/serial-item-processing)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Fan-out/Fan-in / Coordination Overhead](/records/tension/coordination-overhead-fan-out-fan-in), [Fan-out/Fan-in / Serial Item Processing](/records/tension/fan-out-fan-in-serial-item-processing)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Sequential Bottleneck](/records/lexicon/sequential-bottleneck)", "term": "Violated by" }, { "description": "serial loop over parallelizable work", "term": "Detected by" }, { "description": "parallelism utilization", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "pipeline design review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const report = await buildFullFooReport(foos);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const partials = await fanOut(partition(foos), buildPartialFooReport);\nconst report = fanIn(partials, mergeFooReports);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "pipeline design review", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Independent Work Units](/records/lexicon/independent-work-units), [Parallelism](/records/architecture/parallelism), [Throughput](/records/architecture/throughput), [Parallel Branch Processing](/records/lexicon/parallel-branch-processing), [Result Aggregation](/records/lexicon/result-aggregation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fan-out-fan-in", "title": "Fan-out/Fan-in" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/architecture-category/streaming-pipeline-dataflow-processing)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: data processing, latency, architecture", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "An approach in which the processing model, periodic batch or continuous stream, is chosen by how fresh the data must be.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Latency Requirement Clarity](/records/lexicon/latency-requirement-clarity)", "term": "Requires" }, { "description": "[Fitness for Purpose](/records/lexicon/fitness-for-purpose)", "term": "Reinforces" }, { "description": "[Latency-Appropriate Processing Model](/records/lexicon/latency-appropriate-processing-model)", "term": "Enables" }, { "description": "[Operational Duplication](/records/lexicon/operational-duplication)", "term": "In tension with" }, { "description": "[One-Size-Fits-All Processing](/records/lexicon/one-size-fits-all-processing)", "term": "Conflicts with" }, { "description": "[Batch-vs-Stream / Operational Duplication](/records/tension/batch-vs-stream-operational-duplication)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[One-Size-Fits-All Processing](/records/lexicon/one-size-fits-all-processing)", "term": "Violated by" }, { "description": "batch cadence mismatched to freshness requirements", "term": "Detected by" }, { "description": "data-freshness lag vs requirement", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "data architecture review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "schedule.daily(() => reprocessAllFoos());", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooStream.subscribe(foo => processFoo(foo));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "data architecture review", "term": "Checked by" }, { "description": "Every stage, stream source, accumulator and data edge of a pipeline", "term": "Population" }, { "description": "A verdict stands until a stage, its contract or the input volume changes", "term": "Freshness" }, { "description": "The pipeline test or the memory test fails a stage that materializes unbounded input or hides a data dependency", "term": "Refusal" }, { "description": "Stage contracts read from source, plus lag, throughput and memory measured under load", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The stage contract, which each stage's behavior under load is compared against", "term": "Authoritative side" }, { "description": "[Latency Requirement Clarity](/records/lexicon/latency-requirement-clarity), [Fitness for Purpose](/records/lexicon/fitness-for-purpose), [Latency-Appropriate Processing Model](/records/lexicon/latency-appropriate-processing-model)", "term": "Depends on" }, { "description": "[One-Size-Fits-All Processing](/records/lexicon/one-size-fits-all-processing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-batch-vs-stream", "title": "Batch-vs-Stream" } ], "title": "Streaming / Pipeline / Dataflow Processing" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_plugin_architecture[\"Plugin Architecture\"]\n n_extension_points[\"Extension Points\"]\n n_inversion_of_control[\"Inversion of Control (IoC)\"]\n n_dependency_injection[\"Dependency Injection\"]\n n_service_registry[\"Service Registry\"]\n n_registry_pattern[\"Registry Pattern\"]\n n_service_locator_pattern[\"Service Locator Pattern\"]\n n_feature_toggle[\"Feature Toggle\"]\n n_plugin_architecture --> n_extension_points\n n_extension_points --> n_plugin_architecture\n n_inversion_of_control --> n_dependency_injection" } ], "icon": "bi-collection", "id": "architecture-category-plugin-extensibility-ioc", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: component, runtime, system", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of building a small core that discovers and loads plugins through declared extension points.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Extension Points](/records/architecture/extension-points), [Stable Interfaces](/records/architecture/stable-interfaces), [Discovery](/records/lexicon/discovery)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Modularity](/records/architecture/modularity)", "term": "Reinforces" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Enables" }, { "description": "[Static Analysis](/records/architecture/static-analysis), [Security](/records/lexicon/security)", "term": "In tension with" }, { "description": "[Hardcoded Extensions](/records/lexicon/hardcoded-extensions)", "term": "Conflicts with" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Modularity](/records/architecture/modularity), [Composability](/records/architecture/composability), [Replaceability](/records/architecture/replaceability), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Self-Describing Architecture](/records/architecture/self-describing-architecture), [Extension Points](/records/architecture/extension-points)", "term": "Referenced by" }, { "description": "[Plugin Architecture / Static Analysis](/records/tension/plugin-architecture-static-analysis), [Plugin Architecture / Security](/records/tension/plugin-architecture-security)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Extensions](/records/lexicon/hardcoded-extensions)", "term": "Violated by" }, { "description": "direct plugin imports, central switch for plugins", "term": "Detected by" }, { "description": "plugin isolation score", "term": "Measured by" }, { "description": "[Extension Points](/records/architecture/extension-points), [Registry Pattern](/records/architecture/registry-pattern)", "term": "Refactored by" }, { "description": "plugin contract tests, dependency rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooApp {\n run() { new FooExport().run(); new BarExport().run(); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooPlugin { name: string; setup(app: FooApp): void; }\nclass FooApp {\n constructor(private readonly plugins: readonly FooPlugin[]) {}\n run() { this.plugins.forEach(plugin => plugin.setup(this)); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "plugin contract tests, dependency rules", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Extension Points](/records/architecture/extension-points), [Stable Interfaces](/records/architecture/stable-interfaces), [Discovery](/records/lexicon/discovery), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Modularity](/records/architecture/modularity), [Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Depends on" }, { "description": "[Hardcoded Extensions](/records/lexicon/hardcoded-extensions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-plugin-architecture", "title": "Plugin Architecture" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: framework, plugin, module", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that exposes named hooks or interfaces where new behavior can be added without editing the core.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Contracts](/records/lexicon/contracts)", "term": "Requires" }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Reinforces" }, { "description": "[Third-Party Extension](/records/lexicon/third-party-extension)", "term": "Enables" }, { "description": "[API Surface Growth](/records/lexicon/api-surface-growth)", "term": "In tension with" }, { "description": "[Closed Core](/records/lexicon/closed-core)", "term": "Conflicts with" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Referenced by" }, { "description": "[Extension Points / API Surface Growth](/records/tension/api-surface-growth-extension-points)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Closed Core](/records/lexicon/closed-core)", "term": "Violated by" }, { "description": "repeated core edits for variants", "term": "Detected by" }, { "description": "extension coverage", "term": "Measured by" }, { "description": "[Extract Interface](/records/lexicon/extract-interface)", "term": "Refactored by" }, { "description": "extension tests, API review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function saveFoo(foo: Foo) {\n validateFoo(foo);\n fooStore.save(foo);\n sendFooEmail(foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooHooks = { beforeSave: Array<(foo: Foo) => void>; afterSave: Array<(foo: Foo) => void> };\nfunction saveFoo(foo: Foo, hooks: FooHooks) {\n hooks.beforeSave.forEach(hook => hook(foo));\n fooStore.save(foo);\n hooks.afterSave.forEach(hook => hook(foo));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "extension tests, API review", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Contracts](/records/lexicon/contracts), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Plugin Architecture](/records/architecture/plugin-architecture), [Third-Party Extension](/records/lexicon/third-party-extension)", "term": "Depends on" }, { "description": "[Closed Core](/records/lexicon/closed-core)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-extension-points", "title": "Extension Points" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: framework, runtime, component", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a framework or composition root owns object creation and control flow, and application code supplies the parts it calls.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Composition Root](/records/lexicon/composition-root)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Reinforces" }, { "description": "[Framework Control Flow](/records/lexicon/framework-control-flow), [Plugins](/records/lexicon/plugins)", "term": "Enables" }, { "description": "[Traceability](/records/architecture/traceability)", "term": "In tension with" }, { "description": "[Direct Control Ownership](/records/lexicon/direct-control-ownership)", "term": "Conflicts with" }, { "description": "[Inversion of Control (IoC) / Traceability](/records/tension/inversion-of-control-ioc-traceability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Direct Control Ownership](/records/lexicon/direct-control-ownership)", "term": "Violated by" }, { "description": "scattered object lifecycle construction", "term": "Detected by" }, { "description": "composition centralization", "term": "Measured by" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection), [Composition Root](/records/lexicon/composition-root)", "term": "Refactored by" }, { "description": "lifecycle rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooJob {\n run() {\n const store = new SqlFooStore();\n return store.save(makeFoo());\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooJob {\n constructor(private readonly make: () => Foo, private readonly store: FooStore) {}\n run() { return this.store.save(this.make()); }\n}\ncontainer.run(FooJob);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lifecycle rules", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Composition Root](/records/lexicon/composition-root), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Dependency Injection](/records/architecture/dependency-injection), [Framework Control Flow](/records/lexicon/framework-control-flow), [Plugins](/records/lexicon/plugins)", "term": "Depends on" }, { "description": "[Direct Control Ownership](/records/lexicon/direct-control-ownership)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-inversion-of-control", "title": "Inversion of Control (IoC)" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: class, module, component", "Aliases: DI", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that passes an object its dependencies from outside, usually through its constructor.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction), [Composition Root](/records/lexicon/composition-root)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Mocking](/records/lexicon/mocking), [Replaceability](/records/architecture/replaceability)", "term": "Enables" }, { "description": "[Constructor Complexity](/records/lexicon/constructor-complexity)", "term": "In tension with" }, { "description": "[Hardcoded Instantiation](/records/lexicon/hardcoded-instantiation), [Ambient Context](/records/architecture/ambient-context)", "term": "Conflicts with" }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Singleton Pattern](/records/architecture/singleton-pattern), [Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Referenced by" }, { "description": "[Dependency Injection / Constructor Complexity](/records/tension/constructor-complexity-dependency-injection)", "term": "Tensions" }, { "description": "[Adapter Pattern](/records/architecture/adapter-pattern): Dependency injection supplies a dependency from outside, while an adapter makes an incompatible interface fit the one expected.", "term": "Distinct from" }, { "description": "[Composition Root](/records/lexicon/composition-root): Dependency injection is passing dependencies in, while the composition root is the one place where they are wired.", "term": "Distinct from" }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture): Dependency injection is how one object receives its dependencies, while ports and adapters is how a whole core is isolated from its technologies.", "term": "Distinct from" }, { "description": "[Singleton Pattern](/records/architecture/singleton-pattern): Dependency injection passes a dependency in, while a singleton is reached through a global access point.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Instantiation](/records/lexicon/hardcoded-instantiation)", "term": "Violated by" }, { "description": "direct construction of external dependencies", "term": "Detected by" }, { "description": "injected dependency ratio", "term": "Measured by" }, { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Refactored by" }, { "description": "lint rules, dependency review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n private readonly clock = new SystemClock();\n private readonly store = new SqlFooStore();\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {\n constructor(private readonly clock: Clock, private readonly store: FooStore) {}\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules, dependency review", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Abstraction](/records/architecture/abstraction), [Composition Root](/records/lexicon/composition-root), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability), [Mocking](/records/lexicon/mocking), [Replaceability](/records/architecture/replaceability)", "term": "Depends on" }, { "description": "[Hardcoded Instantiation](/records/lexicon/hardcoded-instantiation), [Ambient Context](/records/architecture/ambient-context)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-dependency-injection", "title": "Dependency Injection" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, service, plugin", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism where services or plugins register under a key and are resolved by that key at runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Registration Protocol](/records/lexicon/registration-protocol)", "term": "Requires" }, { "description": "[Discovery](/records/lexicon/discovery), [Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Reinforces" }, { "description": "[Dynamic Resolution](/records/lexicon/dynamic-resolution)", "term": "Enables" }, { "description": "[Registry Availability](/records/lexicon/registry-availability)", "term": "In tension with" }, { "description": "[Hardcoded Lookup](/records/lexicon/hardcoded-lookup)", "term": "Conflicts with" }, { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Referenced by" }, { "description": "[Service Registry / Registry Availability](/records/tension/registry-availability-service-registry)", "term": "Tensions" }, { "description": "[Health Checks](/records/architecture/health-checks): A service registry resolves a key to a registered service, while health checks report whether an instance is ready to serve.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Lookup](/records/lexicon/hardcoded-lookup)", "term": "Violated by" }, { "description": "static lookup tables", "term": "Detected by" }, { "description": "registry coverage", "term": "Measured by" }, { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Refactored by" }, { "description": "startup checks, [health checks](/records/architecture/health-checks)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooService = new FooService(new SqlFooStore());\nconst barService = new BarService(new SqlBarStore());", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const services = new ServiceRegistry();\nservices.register(\"FooStore\", () => new SqlFooStore());\nservices.register(\"FooService\", r => new FooService(r.resolve(\"FooStore\")));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "startup checks, health checks", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Registration Protocol](/records/lexicon/registration-protocol), [Discovery](/records/lexicon/discovery), [Dynamic Binding](/records/architecture/dynamic-binding), [Dynamic Resolution](/records/lexicon/dynamic-resolution)", "term": "Depends on" }, { "description": "[Hardcoded Lookup](/records/lexicon/hardcoded-lookup)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-service-registry", "title": "Service Registry" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, module, plugin", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that replaces a conditional over kinds with a keyed table that each kind registers itself into.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Keyed Registration](/records/lexicon/keyed-registration)", "term": "Requires" }, { "description": "[Discovery](/records/lexicon/discovery), [Factory Pattern](/records/architecture/factory-pattern)", "term": "Reinforces" }, { "description": "[Dynamic Lookup](/records/lexicon/dynamic-lookup)", "term": "Enables" }, { "description": "[Global State](/records/lexicon/global-state)", "term": "In tension with" }, { "description": "[Direct Reference](/records/lexicon/direct-reference)", "term": "Conflicts with" }, { "description": "[Registry Pattern / Global State](/records/tension/global-state-registry-pattern)", "term": "Tensions" }, { "description": "[Factory Pattern](/records/architecture/factory-pattern): A registry replaces a conditional over kinds with a keyed table, while a factory owns how one object and its defaults are built.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ungoverned Global Registry](/records/lexicon/ungoverned-global-registry)", "term": "Violated by" }, { "description": "mutable global maps without lifecycle", "term": "Detected by" }, { "description": "registry consistency", "term": "Measured by" }, { "description": "[Narrow Type](/records/lexicon/narrow-type)", "term": "Refactored by" }, { "description": "registry validation", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function makeFoo(kind: string) {\n if (kind === \"foo\") return new Foo1();\n if (kind === \"bar\") return new Bar();\n throw new Error(\"unknown kind\");\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooFactory = () => Foo;\nconst registry = new Map();\nexport const registerFoo = (kind: string, factory: FooFactory) => registry.set(kind, factory);\nexport const makeFoo = (kind: string) => registry.get(kind)?.() ?? fail(`unknown ${kind}`);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "registry validation", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Keyed Registration](/records/lexicon/keyed-registration), [Discovery](/records/lexicon/discovery), [Factory Pattern](/records/architecture/factory-pattern), [Dynamic Lookup](/records/lexicon/dynamic-lookup)", "term": "Depends on" }, { "description": "[Direct Reference](/records/lexicon/direct-reference)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-registry-pattern", "title": "Registry Pattern" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: runtime, dependency access", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which code fetches its dependencies from a global registry at the point of use.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Registry](/records/lexicon/registry)", "term": "Requires" }, { "description": "[Runtime Lookup](/records/lexicon/runtime-lookup)", "term": "Reinforces" }, { "description": "[Late Resolution](/records/lexicon/late-resolution)", "term": "Enables" }, { "description": "[Testability](/records/architecture/testability), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Explicit Dependencies](/records/lexicon/explicit-dependencies)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Service Locator Pattern / Testability](/records/tension/service-locator-pattern-testability), [Service Locator Pattern / Dependency Inversion Principle (DIP)](/records/tension/dependency-inversion-principle-dip-service-locator-pattern), [Service Locator Pattern / Explicit Dependencies](/records/tension/explicit-dependencies-service-locator-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Violated by" }, { "description": "service locator calls inside domain logic", "term": "Detected by" }, { "description": "hidden dependency count", "term": "Measured by" }, { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Refactored by" }, { "description": "banned API rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooController {\n save(foo: Foo) {\n const store = serviceLocator.resolve(\"FooStore\");\n return store.save(foo);\n }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooController {\n constructor(private readonly store: FooStore) {}\n save(foo: Foo) { return this.store.save(foo); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "banned API rules", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Registry](/records/lexicon/registry), [Runtime Lookup](/records/lexicon/runtime-lookup), [Late Resolution](/records/lexicon/late-resolution)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-service-locator-pattern", "title": "Service Locator Pattern" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Plugin / Extensibility / IoC](/records/architecture-category/plugin-extensibility-ioc)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, release, runtime", "Aliases: Feature Flag", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that switches a code path on or off at runtime from externally held flag state, so a release can happen without a deploy.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Externalized Flag State](/records/lexicon/externalized-flag-state)", "term": "Requires" }, { "description": "[Continuous Delivery](/records/lexicon/continuous-delivery), [Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Reinforces" }, { "description": "[Decoupled Deploy and Release](/records/lexicon/decoupled-deploy-and-release), [Gradual Rollout](/records/lexicon/gradual-rollout)", "term": "Enables" }, { "description": "[Flag Debt](/records/lexicon/flag-debt)", "term": "In tension with" }, { "description": "[Hardcoded Branch Constant](/records/lexicon/hardcoded-branch-constant)", "term": "Conflicts with" }, { "description": "[Feature Toggle / Flag Debt](/records/tension/feature-toggle-flag-debt)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Branch Constant](/records/lexicon/hardcoded-branch-constant)", "term": "Violated by" }, { "description": "compile-time flags requiring redeploy to flip", "term": "Detected by" }, { "description": "redeploys per behavior change", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "release review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (NEW_FOO_FLOW_ENABLED) runNewFooFlow();\nelse runOldFooFlow();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (featureFlags.enabled(\"new-foo-flow\", { user, percentage: 10 })) runNewFooFlow();\nelse runOldFooFlow();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "release review", "term": "Checked by" }, { "description": "Every extension point, plugin, registration and dependency construction site", "term": "Population" }, { "description": "A verdict stands until a plugin, a registration or the composition root changes", "term": "Freshness" }, { "description": "The dependency rule, plugin contract test or banned-API rule fails a change that hardcodes an extension or hides a dependency", "term": "Refusal" }, { "description": "Imports from the core to plugins, construction sites and registry contents, read from source and at startup", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The extension contract, which every plugin conforms to while the core names no plugin", "term": "Authoritative side" }, { "description": "[Externalized Flag State](/records/lexicon/externalized-flag-state), [Continuous Delivery](/records/lexicon/continuous-delivery), [Runtime Extensibility](/records/architecture/runtime-extensibility), [Decoupled Deploy and Release](/records/lexicon/decoupled-deploy-and-release), [Gradual Rollout](/records/lexicon/gradual-rollout)", "term": "Depends on" }, { "description": "[Hardcoded Branch Constant](/records/lexicon/hardcoded-branch-constant)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-feature-toggle", "title": "Feature Toggle" } ], "title": "Plugin / Extensibility / IoC" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_self_healing_architecture[\"Self-Healing Architecture\"]\n n_health_checks[\"Health Checks\"]\n n_failover[\"Failover\"]\n n_redundancy[\"Redundancy\"]\n n_replication[\"Replication\"]\n n_auto_scaling[\"Auto-Scaling\"]\n n_auto_remediation[\"Auto-Remediation\"]\n n_rollback[\"Rollback\"]\n n_blue_green_deployment[\"Blue-Green Deployment\"]\n n_canary_deployment[\"Canary Deployment\"]\n n_chaos_engineering[\"Chaos Engineering\"]\n n_graceful_shutdown[\"Graceful Shutdown\"]\n n_raid_redundancy[\"RAID Redundancy\"]\n n_self_healing_architecture --> n_health_checks\n n_self_healing_architecture --> n_auto_remediation\n n_health_checks --> n_self_healing_architecture\n n_failover --> n_redundancy\n n_redundancy --> n_failover\n n_replication --> n_failover\n n_auto_remediation --> n_self_healing_architecture\n n_blue_green_deployment --> n_rollback\n n_chaos_engineering --> n_self_healing_architecture\n n_raid_redundancy --> n_redundancy" } ], "icon": "bi-collection", "id": "architecture-category-self-healing-recovery-deployment-safety", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, infrastructure, runtime", "Aliases: Self-Healing", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability of a system to detect a failed component from its health signals and restore it without human action.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Observability](/records/architecture/observability), [Health Checks](/records/architecture/health-checks), [Automation](/records/lexicon/automation)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Reinforces" }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Enables" }, { "description": "[Unsafe Automation](/records/lexicon/unsafe-automation)", "term": "In tension with" }, { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Conflicts with" }, { "description": "[Resilience](/records/architecture/resilience), [Health Checks](/records/architecture/health-checks), [Auto-Remediation](/records/architecture/auto-remediation), [Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Referenced by" }, { "description": "[Self-Healing Architecture / Unsafe Automation](/records/tension/self-healing-architecture-unsafe-automation)", "term": "Tensions" }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation): A self-healing architecture is the whole system restoring its components, while auto-remediation is one automated response to one known failure.", "term": "Distinct from" }, { "description": "[Automation](/records/lexicon/automation): Self-healing is restoring failed components without human action, while automation is any task run without manual intervention.", "term": "Distinct from" }, { "description": "[Recovery](/records/lexicon/recovery): Self-healing is recovery that the system starts itself, while recovery is returning to correct operation by any means.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Violated by" }, { "description": "recurring manual recovery steps", "term": "Detected by" }, { "description": "MTTR, auto-recovery success", "term": "Measured by" }, { "description": "[Health Checks](/records/architecture/health-checks), [Recovery Policy](/records/lexicon/recovery-policy)", "term": "Refactored by" }, { "description": "orchestration policy, runbooks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "process.on(\"error\", error => fooLog.record(error));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "supervisor.watch(\"foo-worker\", {\n start: startFooWorker,\n health: fooWorkerHealth,\n restart: { maxAttempts: 5, backoffMs: 1000 },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "orchestration policy, runbooks", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Observability](/records/architecture/observability), [Health Checks](/records/architecture/health-checks), [Automation](/records/lexicon/automation), [Resilience](/records/architecture/resilience), [Auto-Remediation](/records/architecture/auto-remediation)", "term": "Depends on" }, { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-self-healing-architecture", "title": "Self-Healing Architecture" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: services", "Scope: service, deployment, runtime", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that reports whether an instance and the dependencies it needs are ready to serve, so routing and restarts can act on it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Observable Health Criteria](/records/lexicon/observable-health-criteria)", "term": "Requires" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture), [Load Balancing](/records/architecture/load-balancing)", "term": "Reinforces" }, { "description": "[Readiness/Liveness Routing](/records/lexicon/readiness-liveness-routing)", "term": "Enables" }, { "description": "[False Positives](/records/lexicon/false-positives)", "term": "In tension with" }, { "description": "[Blind Routing](/records/lexicon/blind-routing)", "term": "Conflicts with" }, { "description": "[Service Discovery](/records/architecture/service-discovery), [Load Balancing](/records/architecture/load-balancing), [Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Referenced by" }, { "description": "[Health Checks / False Positives](/records/tension/false-positives-health-checks)", "term": "Tensions" }, { "description": "[Load Balancing](/records/architecture/load-balancing): Health checks report whether an instance can serve, while load balancing spreads requests across the instances that can.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blind Routing](/records/lexicon/blind-routing)", "term": "Violated by" }, { "description": "missing or shallow health endpoint", "term": "Detected by" }, { "description": "health-check accuracy", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "deployment policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.get(\"/health\", () => \"ok\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.get(\"/health\", async () => {\n const fooStoreOk = await fooStore.ping();\n const eventBusOk = await eventBus.ping();\n return {\n state: fooStoreOk && eventBusOk ? \"ready\" : \"blocked\",\n checks: { fooStore: fooStoreOk, eventBus: eventBusOk },\n };\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment policy", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Observable Health Criteria](/records/lexicon/observable-health-criteria), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Load Balancing](/records/architecture/load-balancing), [Readiness/Liveness Routing](/records/lexicon/readiness-liveness-routing)", "term": "Depends on" }, { "description": "[Blind Routing](/records/lexicon/blind-routing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-health-checks", "title": "Health Checks" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: service, infrastructure, data", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that switches traffic or reads to a standby instance when the active one fails.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Redundancy](/records/architecture/redundancy), [Health Detection](/records/lexicon/health-detection)", "term": "Requires" }, { "description": "[Availability](/records/lexicon/availability)", "term": "Reinforces" }, { "description": "[Continuity During Failure](/records/lexicon/continuity-during-failure)", "term": "Enables" }, { "description": "[Consistency](/records/architecture/consistency)", "term": "In tension with" }, { "description": "[Single Instance Dependency](/records/lexicon/single-instance-dependency)", "term": "Conflicts with" }, { "description": "[Service Discovery](/records/architecture/service-discovery), [Redundancy](/records/architecture/redundancy), [Replication](/records/architecture/replication)", "term": "Referenced by" }, { "description": "[Failover / Consistency](/records/tension/consistency-failover)", "term": "Tensions" }, { "description": "[Redundancy](/records/architecture/redundancy): Failover is the switch to a standby, while redundancy is keeping the standby there to switch to.", "term": "Distinct from" }, { "description": "[Replication](/records/architecture/replication): Failover switches traffic to another instance, while replication keeps that instance's data current.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Instance Dependency](/records/lexicon/single-instance-dependency)", "term": "Violated by" }, { "description": "single active dependency with no failover", "term": "Detected by" }, { "description": "failover time, [availability](/records/lexicon/availability)", "term": "Measured by" }, { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Refactored by" }, { "description": "disaster recovery tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await primaryFooStore.find(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await failover.read([\n primaryFooStore,\n secondaryFooStore,\n], store => store.find(id));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "disaster recovery tests", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Redundancy](/records/architecture/redundancy), [Health Detection](/records/lexicon/health-detection), [Availability](/records/lexicon/availability), [Continuity During Failure](/records/lexicon/continuity-during-failure)", "term": "Depends on" }, { "description": "[Single Instance Dependency](/records/lexicon/single-instance-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-failover", "title": "Failover" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: infrastructure, service, data", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that keeps spare instances or capacity for a critical component, spread across failure domains.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Replication or Alternate Capacity](/records/lexicon/replication-or-alternate-capacity)", "term": "Requires" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Failover](/records/architecture/failover)", "term": "Enables" }, { "description": "[Cost](/records/lexicon/cost)", "term": "In tension with" }, { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Conflicts with" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Failover](/records/architecture/failover), [RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" }, { "description": "[Redundancy / Cost](/records/tension/cost-redundancy)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Violated by" }, { "description": "SPOF analysis", "term": "Detected by" }, { "description": "redundancy factor", "term": "Measured by" }, { "description": "[Read Replica](/records/architecture/read-replica), [Failover](/records/architecture/failover)", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooService = deploy({ replicas: 1 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooService = deploy({ replicas: 3, spreadAcross: [\"zone-a\", \"zone-b\", \"zone-c\"] });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Replication or Alternate Capacity](/records/lexicon/replication-or-alternate-capacity), [Fault Tolerance](/records/architecture/fault-tolerance), [Failover](/records/architecture/failover)", "term": "Depends on" }, { "description": "[Single Point of Failure](/records/lexicon/single-point-of-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-redundancy", "title": "Redundancy" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: database, service, cache", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that keeps copies of data on several nodes under a declared consistency policy, such as a write quorum.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Consistency Policy](/records/lexicon/consistency-policy)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Availability](/records/lexicon/availability)", "term": "Reinforces" }, { "description": "[Read Scaling](/records/lexicon/read-scaling), [Failover](/records/architecture/failover)", "term": "Enables" }, { "description": "[Consistency Lag](/records/lexicon/consistency-lag)", "term": "In tension with" }, { "description": "[Single Copy State](/records/lexicon/single-copy-state)", "term": "Conflicts with" }, { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Referenced by" }, { "description": "[Replication / Consistency Lag](/records/tension/consistency-lag-replication)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Copy State](/records/lexicon/single-copy-state)", "term": "Violated by" }, { "description": "SPOF data stores", "term": "Detected by" }, { "description": "replication lag, replica count", "term": "Measured by" }, { "description": "[Read Replica](/records/architecture/read-replica), [Consistency Contract](/records/lexicon/consistency-contract)", "term": "Refactored by" }, { "description": "infrastructure policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await primaryFooStore.save(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await replicatedFooStore.save(foo, { replicas: 3, writeQuorum: 2 });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure policy", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Consistency Policy](/records/lexicon/consistency-policy), [Scalability](/records/architecture/scalability), [Availability](/records/lexicon/availability), [Read Scaling](/records/lexicon/read-scaling), [Failover](/records/architecture/failover)", "term": "Depends on" }, { "description": "[Single Copy State](/records/lexicon/single-copy-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-replication", "title": "Replication" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: deployment, service, infrastructure", "Aliases: Demand-Based Capacity", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change the number of running instances automatically, between set bounds, from a load metric.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Horizontal Scalability](/records/lexicon/horizontal-scalability), [Metrics](/records/lexicon/metrics)", "term": "Requires" }, { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "[Cost/Cold Start](/records/lexicon/cost-cold-start), [Fixed Capacity](/records/lexicon/fixed-capacity)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Elasticity](/records/architecture/elasticity), [Statelessness](/records/architecture/statelessness)", "term": "Referenced by" }, { "description": "[Auto-Scaling / Cost/Cold Start](/records/tension/auto-scaling-cost-cold-start), [Auto-Scaling / Fixed Capacity](/records/tension/auto-scaling-fixed-capacity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Fixed-Capacity Design](/records/lexicon/fixed-capacity-design)", "term": "Violated by" }, { "description": "saturation under load without scale policy", "term": "Detected by" }, { "description": "scaling latency, saturation rate", "term": "Measured by" }, { "description": "[Autoscaling Policy](/records/lexicon/autoscaling-policy), [Externalize Session State](/records/lexicon/externalize-session-state)", "term": "Refactored by" }, { "description": "infrastructure-as-code policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deployFooWorkers({ replicas: 4 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "deployFooWorkers({\n minReplicas: 2,\n maxReplicas: 20,\n scaleOn: { queueDepthPerWorker: 100 },\n scaleInCooldownSeconds: 300,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure-as-code policy", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Horizontal Scalability](/records/lexicon/horizontal-scalability), [Metrics](/records/lexicon/metrics), [Elasticity](/records/architecture/elasticity)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-auto-scaling", "title": "Auto-Scaling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: runtime, service, infrastructure", "Aliases: Autonomous Recovery", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to run a guarded, automated response, such as a restart, a reset and replay or a compaction, when an alert or a health signal shows a failure whose fix is known.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Health Signal](/records/lexicon/health-signal), [Remediation Workflow](/records/lexicon/remediation-workflow)", "term": "Requires" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Reinforces" }, { "description": "[Incident Reduction](/records/lexicon/incident-reduction), [Reduced Mean Time to Recovery](/records/lexicon/reduced-mean-time-to-recovery)", "term": "Enables" }, { "description": "[Unsafe Automation](/records/lexicon/unsafe-automation), [Manual Remediation](/records/lexicon/manual-remediation)", "term": "In tension with" }, { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Conflicts with" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Referenced by" }, { "description": "[Auto-Remediation / Unsafe Automation](/records/tension/auto-remediation-unsafe-automation), [Auto-Remediation / Manual Remediation](/records/tension/auto-remediation-manual-remediation)", "term": "Tensions" }, { "description": "[Incident Reduction](/records/lexicon/incident-reduction): Auto-remediation is running the known fix, while incident reduction is the fall in incidents that reach a responder as a result.", "term": "Distinct from" }, { "description": "[Reduced Mean Time to Recovery](/records/lexicon/reduced-mean-time-to-recovery): Auto-remediation is running the known fix, while reduced mean time to recovery is the shorter outage that results.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Violated by" }, { "description": "repeated manual runbook actions", "term": "Detected by" }, { "description": "remediation success, false action rate", "term": "Measured by" }, { "description": "[Automate the Runbook](/records/lexicon/automate-the-runbook), [Guardrails](/records/lexicon/guardrails)", "term": "Refactored by" }, { "description": "operations policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "alert.on(\"FooDiskFull\", pageOnCall);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "alert.on(\"FooDiskFull\", async event => {\n await fooStorage.compact(event.volumeId);\n await fooStorage.verify(event.volumeId);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "operations policy", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Health Signal](/records/lexicon/health-signal), [Remediation Workflow](/records/lexicon/remediation-workflow), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Incident Reduction](/records/lexicon/incident-reduction), [Reduced Mean Time to Recovery](/records/lexicon/reduced-mean-time-to-recovery)", "term": "Depends on" }, { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-auto-remediation", "title": "Auto-Remediation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: deployment, release", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that restores the previous versioned release when a deployment fails its verification.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Versioned Artifact](/records/lexicon/versioned-artifact), [Reversible Deployment](/records/lexicon/reversible-deployment)", "term": "Requires" }, { "description": "[Resilience](/records/architecture/resilience), [Recovery](/records/lexicon/recovery)", "term": "Reinforces" }, { "description": "[Fast Failure Recovery](/records/lexicon/fast-failure-recovery)", "term": "Enables" }, { "description": "[Data Migration Compatibility](/records/lexicon/data-migration-compatibility)", "term": "In tension with" }, { "description": "[Irreversible Deployment](/records/lexicon/irreversible-deployment), [Irreversible Migration](/records/architecture/irreversible-migration)", "term": "Conflicts with" }, { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Referenced by" }, { "description": "[Rollback / Data Migration Compatibility](/records/tension/data-migration-compatibility-rollback)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Irreversible Deployment](/records/lexicon/irreversible-deployment)", "term": "Violated by" }, { "description": "no rollback path", "term": "Detected by" }, { "description": "rollback success time", "term": "Measured by" }, { "description": "[Rollback Plan](/records/lexicon/rollback-plan), [Expand-Contract Migration](/records/lexicon/expand-contract-migration)", "term": "Refactored by" }, { "description": "release gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "deploy(fooVersion);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const release = await deploy(fooVersion);\nif (!(await release.verify())) await release.rollback(previousFooVersion);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "release gates", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Versioned Artifact](/records/lexicon/versioned-artifact), [Reversible Deployment](/records/lexicon/reversible-deployment), [Resilience](/records/architecture/resilience), [Recovery](/records/lexicon/recovery), [Fast Failure Recovery](/records/lexicon/fast-failure-recovery)", "term": "Depends on" }, { "description": "[Irreversible Deployment](/records/lexicon/irreversible-deployment), [Irreversible Migration](/records/architecture/irreversible-migration)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-rollback", "title": "Rollback" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: deployment, release", "Aliases: Red-Black Deployment", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that deploys a release to an idle copy of production, verifies it, and switches traffic to it at once.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Parallel Environments](/records/lexicon/parallel-environments)", "term": "Requires" }, { "description": "[Rollback](/records/architecture/rollback), [Availability](/records/lexicon/availability)", "term": "Reinforces" }, { "description": "[Low-Risk Cutover](/records/lexicon/low-risk-cutover)", "term": "Enables" }, { "description": "[Infrastructure Cost](/records/lexicon/infrastructure-cost)", "term": "In tension with" }, { "description": "[In-Place Mutation Only](/records/lexicon/in-place-mutation-only)", "term": "Conflicts with" }, { "description": "[Blue-Green Deployment / Infrastructure Cost](/records/tension/blue-green-deployment-infrastructure-cost)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[In-Place Mutation Only](/records/lexicon/in-place-mutation-only)", "term": "Violated by" }, { "description": "no parallel release environment", "term": "Detected by" }, { "description": "cutover failure rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "deployment pipeline", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "routeAllTraffic(deployFoo(\"v2\"));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const green = await deployFoo(\"v2\");\nawait verify(green);\nawait router.switch({ from: \"blue\", to: \"green\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment pipeline", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Parallel Environments](/records/lexicon/parallel-environments), [Rollback](/records/architecture/rollback), [Availability](/records/lexicon/availability), [Low-Risk Cutover](/records/lexicon/low-risk-cutover)", "term": "Depends on" }, { "description": "[In-Place Mutation Only](/records/lexicon/in-place-mutation-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-blue-green-deployment", "title": "Blue-Green Deployment" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: deployment, release", "Aliases: Canary Release", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that sends a small share of traffic to a new release and widens the share only while its error and latency stay within limits.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Traffic Splitting](/records/lexicon/traffic-splitting), [Observability](/records/architecture/observability)", "term": "Requires" }, { "description": "[Progressive Delivery](/records/lexicon/progressive-delivery)", "term": "Reinforces" }, { "description": "[Controlled Exposure](/records/lexicon/controlled-exposure)", "term": "Enables" }, { "description": "[Rollout Complexity](/records/lexicon/rollout-complexity)", "term": "In tension with" }, { "description": "[Big-Bang Release](/records/architecture/big-bang-release)", "term": "Conflicts with" }, { "description": "[Canary Deployment / Rollout Complexity](/records/tension/canary-deployment-rollout-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Big-Bang Release](/records/architecture/big-bang-release)", "term": "Violated by" }, { "description": "no staged traffic policy", "term": "Detected by" }, { "description": "canary error budget, rollback trigger rate", "term": "Measured by" }, { "description": "[Guardrails](/records/lexicon/guardrails)", "term": "Refactored by" }, { "description": "deployment pipeline", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await router.route(\"foo-v2\", 100);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await router.route(\"foo-v2\", 5);\nawait verifyCanary({ errorRate: 0.01, latencyP95Ms: 200 });\nawait router.progressiveShift(\"foo-v2\", [25, 50, 100]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "deployment pipeline", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Traffic Splitting](/records/lexicon/traffic-splitting), [Observability](/records/architecture/observability), [Progressive Delivery](/records/lexicon/progressive-delivery), [Controlled Exposure](/records/lexicon/controlled-exposure)", "term": "Depends on" }, { "description": "[Big-Bang Release](/records/architecture/big-bang-release)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-canary-deployment", "title": "Canary Deployment" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, resilience, operations", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of injecting controlled faults into a running system to test a stated hypothesis about how it recovers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Observability](/records/architecture/observability)", "term": "Requires" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Empirical Resilience Verification](/records/lexicon/empirical-resilience-verification)", "term": "Enables" }, { "description": "[Production Risk](/records/lexicon/production-risk)", "term": "In tension with" }, { "description": "[Untested Failure Assumptions](/records/lexicon/untested-failure-assumptions)", "term": "Conflicts with" }, { "description": "[Chaos Engineering / Production Risk](/records/tension/chaos-engineering-production-risk)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Untested Failure Assumptions](/records/lexicon/untested-failure-assumptions)", "term": "Violated by" }, { "description": "no fault-injection testing of recovery paths", "term": "Detected by" }, { "description": "unverified failure-mode count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "resilience review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "assumeFooSurvivesZoneLoss();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "chaos.experiment(\"foo-zone-loss\", {\n inject: () => killZone(\"zone-a\"),\n hypothesis: () => fooHealth.available(),\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "resilience review", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Observability](/records/architecture/observability), [Self-Healing Architecture](/records/architecture/self-healing-architecture), [Fault Tolerance](/records/architecture/fault-tolerance), [Empirical Resilience Verification](/records/lexicon/empirical-resilience-verification)", "term": "Depends on" }, { "description": "[Untested Failure Assumptions](/records/lexicon/untested-failure-assumptions)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-chaos-engineering", "title": "Chaos Engineering" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: production systems", "Scope: service, runtime, resilience", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that, on a stop signal, stops accepting work, drains in-flight work and closes connections before the process exits.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Lifecycle Signals](/records/lexicon/lifecycle-signals)", "term": "Requires" }, { "description": "[Reliability](/records/lexicon/reliability), [Data Integrity](/records/lexicon/data-integrity)", "term": "Reinforces" }, { "description": "[In-Flight Work Drain](/records/lexicon/in-flight-work-drain), [Connection Cleanup](/records/lexicon/connection-cleanup)", "term": "Enables" }, { "description": "[Shutdown Latency](/records/lexicon/shutdown-latency)", "term": "In tension with" }, { "description": "[Hard Process Kill](/records/lexicon/hard-process-kill)", "term": "Conflicts with" }, { "description": "[Graceful Shutdown / Shutdown Latency](/records/tension/graceful-shutdown-shutdown-latency)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hard Process Kill](/records/lexicon/hard-process-kill)", "term": "Violated by" }, { "description": "dropped in-flight work on deploy/restart", "term": "Detected by" }, { "description": "requests lost per restart", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "operations review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "process.on(\"SIGTERM\", () => process.exit(0));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "process.on(\"SIGTERM\", async () => {\n server.stopAccepting();\n await fooQueue.drain();\n await server.close();\n process.exit(0);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "operations review", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Lifecycle Signals](/records/lexicon/lifecycle-signals), [Reliability](/records/lexicon/reliability), [Data Integrity](/records/lexicon/data-integrity), [In-Flight Work Drain](/records/lexicon/in-flight-work-drain), [Connection Cleanup](/records/lexicon/connection-cleanup)", "term": "Depends on" }, { "description": "[Hard Process Kill](/records/lexicon/hard-process-kill)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-graceful-shutdown", "title": "Graceful Shutdown" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/architecture-category/self-healing-recovery-deployment-safety)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: managed infrastructure", "Scope: storage, redundancy, infrastructure", "Aliases: Redundant Array of Independent Disks", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for spreading data across several disks with mirroring or parity, so the loss of a disk loses no data.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Multiple Physical Disks](/records/lexicon/multiple-physical-disks)", "term": "Requires" }, { "description": "[Redundancy](/records/architecture/redundancy), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Reinforces" }, { "description": "[Disk-Failure Survival](/records/lexicon/disk-failure-survival), [Parity-Based Recovery](/records/lexicon/parity-based-recovery)", "term": "Enables" }, { "description": "[Write Amplification](/records/lexicon/write-amplification)", "term": "In tension with" }, { "description": "[Single-Disk Point of Failure](/records/lexicon/single-disk-point-of-failure)", "term": "Conflicts with" }, { "description": "[RAID Redundancy / Write Amplification](/records/tension/raid-redundancy-write-amplification)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single-Disk Point of Failure](/records/lexicon/single-disk-point-of-failure)", "term": "Violated by" }, { "description": "total data loss when one drive fails", "term": "Detected by" }, { "description": "tolerated simultaneous disk failures", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "storage architecture review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const store = new SingleDiskFooStore(\"/dev/sda\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const store = new FooStore({\n volume: raidArray({ level: 10, disks: [\"/dev/sda\", \"/dev/sdb\", \"/dev/sdc\", \"/dev/sdd\"] }),\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "storage architecture review", "term": "Checked by" }, { "description": "Every service, replica, release and recovery path in production", "term": "Population" }, { "description": "A verdict stands until the topology, the release or the recovery policy changes, and is renewed by each recovery drill", "term": "Freshness" }, { "description": "The release gate, disaster-recovery test or orchestration policy blocks a release or topology without a working recovery path", "term": "Refusal" }, { "description": "Health signals, recovery outcomes and drill results recorded against each service", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The recovery policy, which each drill and recovery outcome is compared against", "term": "Authoritative side" }, { "description": "[Multiple Physical Disks](/records/lexicon/multiple-physical-disks), [Redundancy](/records/architecture/redundancy), [Fault Tolerance](/records/architecture/fault-tolerance), [Disk-Failure Survival](/records/lexicon/disk-failure-survival), [Parity-Based Recovery](/records/lexicon/parity-based-recovery)", "term": "Depends on" }, { "description": "[Single-Disk Point of Failure](/records/lexicon/single-disk-point-of-failure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-raid-redundancy", "title": "RAID Redundancy" } ], "title": "Self-Healing / Recovery / Deployment Safety" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_schema_validation[\"Schema Validation\"]\n n_type_safety[\"Type Safety\"]\n n_canonical_model[\"Canonical Model\"]\n n_canonical_data_model[\"Canonical Data Model\"]\n n_canonical_schema[\"Canonical Schema\"]\n n_canonicalization[\"Canonicalization\"]\n n_single_source_of_truth[\"Single Source of Truth\"]\n n_normalization[\"Normalization\"]\n n_semantic_consistency[\"Semantic Consistency\"]\n n_ubiquitous_language[\"Ubiquitous Language\"]\n n_intent_revealing_interface[\"Intent-Revealing Interface\"]\n n_principle_of_least_surprise[\"Principle of Least Surprise\"]\n n_database_normalization[\"Database Normalization\"]\n n_canonical_model --> n_semantic_consistency\n n_canonical_model --> n_ubiquitous_language\n n_canonical_model --> n_single_source_of_truth\n n_canonical_data_model --> n_canonical_model\n n_canonical_data_model --> n_normalization\n n_canonical_schema --> n_canonical_data_model\n n_canonical_schema --> n_schema_validation\n n_semantic_consistency --> n_ubiquitous_language\n n_ubiquitous_language --> n_intent_revealing_interface\n n_intent_revealing_interface --> n_principle_of_least_surprise\n n_principle_of_least_surprise --> n_intent_revealing_interface\n n_database_normalization --> n_single_source_of_truth" } ], "icon": "bi-collection", "id": "architecture-category-schema-canonical-data-semantics", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: data, API, message", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that parses incoming data against a schema at the boundary and rejects any payload that does not conform.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Data Contract](/records/architecture/data-contract)", "term": "Reinforces" }, { "description": "[Fail Fast](/records/architecture/fail-fast), [Interoperability](/records/architecture/interoperability)", "term": "Enables" }, { "description": "[Flexible Input](/records/lexicon/flexible-input)", "term": "In tension with" }, { "description": "[Untyped Payloads](/records/lexicon/untyped-payloads)", "term": "Conflicts with" }, { "description": "[Schema Contract](/records/architecture/schema-contract), [Declarative Configuration](/records/architecture/declarative-configuration), [Canonical Schema](/records/architecture/canonical-schema)", "term": "Referenced by" }, { "description": "[Schema Validation / Flexible Input](/records/tension/flexible-input-schema-validation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Trusting External Input](/records/lexicon/trusting-external-input)", "term": "Violated by" }, { "description": "missing validator at boundary", "term": "Detected by" }, { "description": "validation coverage", "term": "Measured by" }, { "description": "[Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto)", "term": "Refactored by" }, { "description": "[runtime validation](/records/reasoning/technique-runtime-validation), CI schema checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = JSON.parse(raw) as Foo;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const FooSchema = object({ id: string(), name: string().min(1), count: integer().min(0) });\nconst foo = FooSchema.parse(JSON.parse(raw));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "runtime validation, CI schema checks", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Schema Contract](/records/architecture/schema-contract), [Correctness](/records/architecture/correctness), [Data Contract](/records/architecture/data-contract), [Fail Fast](/records/architecture/fail-fast), [Interoperability](/records/architecture/interoperability)", "term": "Depends on" }, { "description": "[Untyped Payloads](/records/lexicon/untyped-payloads)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-schema-validation", "title": "Schema Validation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, module, API, data", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that has the compiler reject operations on values of the wrong type before the code runs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Explicit Types](/records/lexicon/explicit-types)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Contracts](/records/lexicon/contracts)", "term": "Reinforces" }, { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Enables" }, { "description": "[Rapid Scripting](/records/lexicon/rapid-scripting)", "term": "In tension with" }, { "description": "[Dynamic Untyped Boundaries](/records/lexicon/dynamic-untyped-boundaries), [Stringly Typed Programming](/records/architecture/stringly-typed-programming)", "term": "Conflicts with" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Data Contract](/records/architecture/data-contract), [Static Analysis](/records/architecture/static-analysis), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Compile-Time Evaluation](/records/architecture/compile-time-evaluation), [Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" }, { "description": "[Type Safety / Rapid Scripting](/records/tension/rapid-scripting-type-safety)", "term": "Tensions" }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation): Type safety rejects wrongly typed operations at compile time, while compile-time evaluation runs computations and checks during the build.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Dynamic Untyped Boundaries](/records/lexicon/dynamic-untyped-boundaries)", "term": "Violated by" }, { "description": "weak type usage, unsafe casts", "term": "Detected by" }, { "description": "type coverage, unsafe cast count", "term": "Measured by" }, { "description": "[Narrow Type](/records/lexicon/narrow-type), [Introduce Boundary DTO](/records/lexicon/introduce-boundary-dto)", "term": "Refactored by" }, { "description": "compiler flags, type checker", "term": "Enforced by" }, { "description": "type-safety", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "function loadFoo(id: string): any { return fooStore.get(id); }\nconst count = loadFoo(\"x\").coutn + 1;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooId = string & { readonly __brand: \"FooId\" };\ntype Foo = Readonly<{ id: FooId; count: number }>;\nfunction loadFoo(id: FooId): Foo | undefined { return fooStore.get(id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compiler flags, type checker", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Explicit Types](/records/lexicon/explicit-types), [Correctness](/records/architecture/correctness), [Contracts](/records/lexicon/contracts), [Static Analysis](/records/architecture/static-analysis)", "term": "Depends on" }, { "description": "[Dynamic Untyped Boundaries](/records/lexicon/dynamic-untyped-boundaries), [Stringly Typed Programming](/records/architecture/stringly-typed-programming)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-type-safety", "title": "Type Safety" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: domain, integration, data", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a concept has one authoritative representation, and every other representation is translated to and from it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Semantic Consistency](/records/architecture/semantic-consistency), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Normalized Translation](/records/lexicon/normalized-translation)", "term": "Enables" }, { "description": "[Bounded Context Autonomy](/records/lexicon/bounded-context-autonomy)", "term": "In tension with" }, { "description": "[Multiple Competing Models](/records/lexicon/multiple-competing-models)", "term": "Conflicts with" }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" }, { "description": "[Canonical Model / Bounded Context Autonomy](/records/tension/bounded-context-autonomy-canonical-model)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Multiple Competing Models](/records/lexicon/multiple-competing-models)", "term": "Violated by" }, { "description": "same concept modeled inconsistently", "term": "Detected by" }, { "description": "model duplication count", "term": "Measured by" }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Refactored by" }, { "description": "schema governance, domain review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type ApiFoo = { foo_id: string; label: string };\ntype DbFoo = { id: string; name: string };\ntype UiFoo = { key: string; title: string };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type Foo = Readonly<{ id: FooId; name: string }>;\nconst fromApi = (value: ApiFoo): Foo => ({ id: fooId(value.foo_id), name: value.label });\nconst toUi = (foo: Foo): UiFoo => ({ key: foo.id, title: foo.name });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema governance, domain review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Single Source of Truth](/records/architecture/single-source-of-truth), [Normalized Translation](/records/lexicon/normalized-translation)", "term": "Depends on" }, { "description": "[Multiple Competing Models](/records/lexicon/multiple-competing-models)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-canonical-model", "title": "Canonical Model" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: integration, enterprise data", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern in which integrated systems exchange data through one shared model, with a mapping per system.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Canonical Model](/records/architecture/canonical-model), [Data Contract](/records/architecture/data-contract)", "term": "Requires" }, { "description": "[Interoperability](/records/architecture/interoperability), [Normalization](/records/architecture/normalization)", "term": "Reinforces" }, { "description": "[Cross-System Mapping](/records/lexicon/cross-system-mapping)", "term": "Enables" }, { "description": "[Bounded Context Purity](/records/lexicon/bounded-context-purity), [Local Model Autonomy](/records/lexicon/local-model-autonomy)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Canonical Schema](/records/architecture/canonical-schema)", "term": "Referenced by" }, { "description": "[Canonical Data Model / Bounded Context Purity](/records/tension/bounded-context-purity-canonical-data-model), [Canonical Data Model / Local Model Autonomy](/records/tension/canonical-data-model-local-model-autonomy)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Multiple Competing Models](/records/lexicon/multiple-competing-models)", "term": "Violated by" }, { "description": "duplicated transformation logic", "term": "Detected by" }, { "description": "transformation duplication", "term": "Measured by" }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Refactored by" }, { "description": "data contract review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "fooTable.insert({ foo_id: foo.id, foo_name: foo.name });\nbarTable.insert({ id: foo.id, label: foo.name });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type CanonicalFoo = Readonly<{ id: FooId; name: string }>;\nfooRepository.save(canonicalFoo);\nbarProjection.apply(canonicalFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "data contract review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Canonical Model](/records/architecture/canonical-model), [Data Contract](/records/architecture/data-contract), [Interoperability](/records/architecture/interoperability), [Normalization](/records/architecture/normalization), [Cross-System Mapping](/records/lexicon/cross-system-mapping)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-canonical-data-model", "title": "Canonical Data Model" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: data, message, API", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of one concept's shape, published once and used by every API, message and store that carries the concept.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Requires" }, { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Reinforces" }, { "description": "[Schema Validation](/records/architecture/schema-validation)", "term": "Enables" }, { "description": "[Service-Specific Schemas](/records/lexicon/service-specific-schemas)", "term": "In tension with" }, { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Conflicts with" }, { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Referenced by" }, { "description": "[Canonical Schema / Service-Specific Schemas](/records/tension/canonical-schema-service-specific-schemas)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Violated by" }, { "description": "schema diff conflict", "term": "Detected by" }, { "description": "schema reuse/conformance rate", "term": "Measured by" }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model), [Versioning](/records/architecture/versioning)", "term": "Refactored by" }, { "description": "[schema registry](/records/lexicon/schema-registry)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooSchema = { id: \"string\", name: \"string\" };\nconst barFooSchema = { fooId: \"text\", label: \"text\" };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const CanonicalFooSchema = schema({ id: fooIdSchema, name: nonEmptyString });\nfooApi.use(CanonicalFooSchema);\nbarProjection.use(CanonicalFooSchema);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema registry", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model), [Schema Contract](/records/architecture/schema-contract), [Schema Validation](/records/architecture/schema-validation)", "term": "Depends on" }, { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-canonical-schema", "title": "Canonical Schema" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: input, data, security", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for converting equivalent values to one normal form before they are compared, stored or checked.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Canonical Format](/records/lexicon/canonical-format)", "term": "Requires" }, { "description": "[Validation](/records/architecture/validation), [Deduplication](/records/lexicon/deduplication)", "term": "Reinforces" }, { "description": "[Idempotency](/records/architecture/idempotency), [Security Checks](/records/lexicon/security-checks)", "term": "Enables" }, { "description": "[Lossless Preservation](/records/lexicon/lossless-preservation)", "term": "In tension with" }, { "description": "[Ambiguous Encoding](/records/lexicon/ambiguous-encoding)", "term": "Conflicts with" }, { "description": "[Canonicalization / Lossless Preservation](/records/tension/canonicalization-lossless-preservation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambiguous Encoding](/records/lexicon/ambiguous-encoding)", "term": "Violated by" }, { "description": "duplicate semantically equivalent values", "term": "Detected by" }, { "description": "normalization defect count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "validation pipeline", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const keys = [\"Foo\", \" foo \", \"FOO\"];\nconst map = new Map(keys.map(key => [key, loadFoo(key)]));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function canonicalFooKey(value: string) { return value.trim().normalize(\"NFKC\").toLowerCase(); }\nconst map = new Map(keys.map(key => [canonicalFooKey(key), loadFoo(canonicalFooKey(key))]));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "validation pipeline", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Canonical Format](/records/lexicon/canonical-format), [Validation](/records/architecture/validation), [Deduplication](/records/lexicon/deduplication), [Idempotency](/records/architecture/idempotency), [Security Checks](/records/lexicon/security-checks)", "term": "Depends on" }, { "description": "[Ambiguous Encoding](/records/lexicon/ambiguous-encoding)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-canonicalization", "title": "Canonicalization" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: configuration, data, rule, schema", "Aliases: SSOT", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each fact, rule or configuration value has one owning definition, and every other value is derived from it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ownership](/records/lexicon/ownership), [Canonical Definition](/records/lexicon/canonical-definition)", "term": "Requires" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Governance](/records/architecture/governance), [Correctness](/records/architecture/correctness)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability), [Decentralization](/records/architecture/decentralization)", "term": "In tension with" }, { "description": "[Duplicated Authority](/records/lexicon/duplicated-authority), [Magic Value](/records/architecture/magic-value)", "term": "Conflicts with" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Canonical Model](/records/architecture/canonical-model), [Database Normalization](/records/architecture/database-normalization), [Derived Record State](/records/architecture/derived-record-state), [Projection Channel](/records/architecture/projection-channel), [Two-Direction Index](/records/architecture/two-direction-index), [Period-Decided Disposition](/records/architecture/period-decided-disposition), [Single Aggregate](/records/architecture/single-aggregate), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Derived Naming Registry](/records/architecture/derived-naming-registry), [Collision Consolidation](/records/architecture/collision-consolidation), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" }, { "description": "[Structural Core](/records/algorithms/structural-core), [Centralization Kernel](/records/algorithms/centralization-kernel), [CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Contracts" }, { "description": "[Single Source of Truth / Availability](/records/tension/availability-single-source-of-truth), [Single Source of Truth / Decentralization](/records/tension/decentralization-single-source-of-truth)", "term": "Tensions" }, { "description": "[Canonical Model](/records/architecture/canonical-model): A single source of truth gives each fact one owner, while a canonical model gives a concept one representation that others translate to and from.", "term": "Distinct from" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary): A single source of truth owns each fact once, while a closed vocabulary limits the words a name slot may hold.", "term": "Distinct from" }, { "description": "[Collision Consolidation](/records/architecture/collision-consolidation): A single source of truth is one owner per fact, while collision consolidation reads a taken filename as evidence of two files doing one job.", "term": "Distinct from" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction): A single source of truth is one owner per fact, while declared jurisdiction is the declaration a naming gate reads its scope from.", "term": "Distinct from" }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code): A single source of truth owns facts, rules and configuration values, while DRY keeps one source for logic and constants in code.", "term": "Distinct from" }, { "description": "[Decentralization](/records/architecture/decentralization): A single source of truth centralizes ownership of a fact, while decentralization spreads decisions and control to the owning teams.", "term": "Distinct from" }, { "description": "[Determinism](/records/architecture/determinism): A single source of truth fixes where a fact lives, while determinism fixes that the same inputs give the same result.", "term": "Distinct from" }, { "description": "[Governance](/records/architecture/governance): A single source of truth owns facts, while governance holds decisions to policy.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Violated by" }, { "description": "conflicting definitions", "term": "Detected by" }, { "description": "duplicate authority count", "term": "Measured by" }, { "description": "[Centralize the Rule](/records/lexicon/centralize-the-rule)", "term": "Refactored by" }, { "description": "config governance, [schema registry](/records/lexicon/schema-registry)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "let fooCount = 0;\nconst foos: Foo[] = [];\nfunction addFoo(foo: Foo) { foos.push(foo); fooCount += 1; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foos: Foo[] = [];\nfunction addFoo(foo: Foo) { foos.push(foo); }\nfunction fooCount() { return foos.length; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "config governance, schema registry", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Ownership](/records/lexicon/ownership), [Canonical Definition](/records/lexicon/canonical-definition), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Consistency](/records/architecture/consistency), [Governance](/records/architecture/governance), [Correctness](/records/architecture/correctness)", "term": "Depends on" }, { "description": "[Duplicated Authority](/records/lexicon/duplicated-authority), [Magic Value](/records/architecture/magic-value)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-single-source-of-truth", "title": "Single Source of Truth" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: database, schema, data model", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for storing each fact once and referring to it by key wherever it is needed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Data Semantics](/records/lexicon/data-semantics)", "term": "Requires" }, { "description": "[Consistency](/records/architecture/consistency), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Reinforces" }, { "description": "[Reduced Redundancy](/records/lexicon/reduced-redundancy)", "term": "Enables" }, { "description": "[Query Performance](/records/lexicon/query-performance), [Denormalized Read Models](/records/lexicon/denormalized-read-models)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" }, { "description": "[Normalization / Query Performance](/records/tension/normalization-query-performance), [Normalization / Denormalized Read Models](/records/tension/denormalized-read-models-normalization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Duplicated Denormalized Columns](/records/lexicon/duplicated-denormalized-columns)", "term": "Violated by" }, { "description": "update anomalies, duplicated facts", "term": "Detected by" }, { "description": "redundancy/anomaly count", "term": "Measured by" }, { "description": "[Entity](/records/architecture/entity), [Database Normalization](/records/architecture/database-normalization), [Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "schema review, database constraints", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type Foo = { id: FooId; barName: string; barEmail: string };\nconst foos: Foo[] = duplicateBarAcrossFoos();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type Foo = { id: FooId; barId: BarId };\ntype Bar = { id: BarId; name: string; email: string };\nconst foos = new Map();\nconst bars = new Map();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema review, database constraints", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Data Semantics](/records/lexicon/data-semantics), [Consistency](/records/architecture/consistency), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Reduced Redundancy](/records/lexicon/reduced-redundancy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-normalization", "title": "Normalization" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: domain, API, data", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which one name carries one meaning across the code, the schemas and the documentation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness), [Interoperability](/records/architecture/interoperability)", "term": "Reinforces" }, { "description": "[Disambiguation](/records/lexicon/disambiguation)", "term": "Enables" }, { "description": "[Polysemy Across Contexts](/records/lexicon/polysemy-across-contexts)", "term": "In tension with" }, { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming), [Inconsistent Error Model](/records/architecture/inconsistent-error-model)", "term": "Conflicts with" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Data Contract](/records/architecture/data-contract), [Semantic Contracts](/records/architecture/semantic-contracts), [Knowledge Graphs](/records/architecture/knowledge-graphs), [Canonical Model](/records/architecture/canonical-model)", "term": "Referenced by" }, { "description": "[Semantic Consistency / Polysemy Across Contexts](/records/tension/polysemy-across-contexts-semantic-consistency)", "term": "Tensions" }, { "description": "[Polysemy Across Contexts](/records/lexicon/polysemy-across-contexts): Semantic consistency is one name keeping one meaning, while polysemy across contexts is a term legitimately meaning different things in different bounded contexts.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming)", "term": "Violated by" }, { "description": "conflicting glossary/schema definitions", "term": "Detected by" }, { "description": "semantic conflict count", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept), [Split Bounded Context](/records/lexicon/split-bounded-context), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Refactored by" }, { "description": "glossary review, schema review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFoo(name: string) {}\nfunction renameFoo(label: string) {}\nfunction findFoo(title: string) {}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooName = string & { readonly __brand: \"FooName\" };\nfunction createFoo(name: FooName) {}\nfunction renameFoo(name: FooName) {}\nfunction findFoo(name: FooName) {}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "glossary review, schema review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language), [Semantic Contracts](/records/architecture/semantic-contracts), [Correctness](/records/architecture/correctness), [Interoperability](/records/architecture/interoperability), [Disambiguation](/records/lexicon/disambiguation)", "term": "Depends on" }, { "description": "[Ambiguous Naming](/records/lexicon/ambiguous-naming), [Inconsistent Error Model](/records/architecture/inconsistent-error-model)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-semantic-consistency", "title": "Semantic Consistency" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: bounded context, domain, codebase", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of using the domain's own terms, agreed with its experts, in conversation, documentation and code alike.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Domain Collaboration](/records/lexicon/domain-collaboration)", "term": "Requires" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Reinforces" }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Enables" }, { "description": "[Cross-Context Terminology](/records/lexicon/cross-context-terminology)", "term": "In tension with" }, { "description": "[Technical/Domain Mismatch](/records/lexicon/technical-domain-mismatch)", "term": "Conflicts with" }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Domain Model](/records/architecture/domain-model), [Bounded Context](/records/architecture/bounded-context), [Domain Service](/records/architecture/domain-service), [Semantic Contracts](/records/architecture/semantic-contracts), [Domain-Specific Language (DSL)](/records/architecture/domain-specific-language), [Canonical Model](/records/architecture/canonical-model), [Semantic Consistency](/records/architecture/semantic-consistency), [Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" }, { "description": "[Ubiquitous Language / Cross-Context Terminology](/records/tension/cross-context-terminology-ubiquitous-language)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Technical/Domain Mismatch](/records/lexicon/technical-domain-mismatch)", "term": "Violated by" }, { "description": "synonym drift, ambiguous names", "term": "Detected by" }, { "description": "naming consistency score", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept)", "term": "Refactored by" }, { "description": "naming rules, domain review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function changeThingState(record: any, code: string) {\n record.s = code;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function activateFoo(foo: Foo) {\n foo.activate();\n fooEvents.emit({ type: \"FooActivated\", fooId: foo.id });\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming rules, domain review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Domain Collaboration](/records/lexicon/domain-collaboration), [Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Semantic Contracts](/records/architecture/semantic-contracts), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Depends on" }, { "description": "[Technical/Domain Mismatch](/records/lexicon/technical-domain-mismatch)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-ubiquitous-language", "title": "Ubiquitous Language" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, method, class, module", "Aliases: Intent-Revealing API", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an operation's name and parameters state what it does for the caller.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Clear Semantics](/records/lexicon/clear-semantics), [Naming Consistency](/records/lexicon/naming-consistency)", "term": "Requires" }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Reinforces" }, { "description": "[Readability](/records/lexicon/readability), [Correct Usage](/records/lexicon/correct-usage)", "term": "Enables" }, { "description": "[Concise Naming](/records/lexicon/concise-naming)", "term": "In tension with" }, { "description": "[Ambiguous API](/records/lexicon/ambiguous-api), [Boolean Trap](/records/architecture/boolean-trap)", "term": "Conflicts with" }, { "description": "[Builder Pattern](/records/architecture/builder-pattern), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Referenced by" }, { "description": "[Intent-Revealing Interface / Concise Naming](/records/tension/concise-naming-intent-revealing-interface)", "term": "Tensions" }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise): An intent-revealing interface states what an operation does in its name and parameters, while least surprise requires the behavior to match what they lead a caller to expect.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambiguous API](/records/lexicon/ambiguous-api), [Boolean Trap](/records/architecture/boolean-trap)", "term": "Violated by" }, { "description": "generic names, unclear parameters", "term": "Detected by" }, { "description": "API clarity review findings", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept), [Replace Boolean with Enum](/records/lexicon/replace-boolean-with-enum), [Value Object](/records/architecture/value-object)", "term": "Refactored by" }, { "description": "naming lint, API review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.update(\"s\", \"A\");\nfoo.apply(3, true);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "foo.activate();\nfoo.reserve({ quantity: 3, notify: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming lint, API review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Clear Semantics](/records/lexicon/clear-semantics), [Naming Consistency](/records/lexicon/naming-consistency), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [Readability](/records/lexicon/readability), [Correct Usage](/records/lexicon/correct-usage)", "term": "Depends on" }, { "description": "[Ambiguous API](/records/lexicon/ambiguous-api), [Boolean Trap](/records/architecture/boolean-trap)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-intent-revealing-interface", "title": "Intent-Revealing Interface" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: API, UX, module behavior", "Aliases: Principle of Least Astonishment, POLA", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an operation behaves the way its name and its conventions lead a caller to expect.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Predictability](/records/architecture/predictability), [Convention](/records/lexicon/convention)", "term": "Requires" }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Reinforces" }, { "description": "[Safe Use](/records/lexicon/safe-use)", "term": "Enables" }, { "description": "[Clever Abstractions](/records/lexicon/clever-abstractions)", "term": "In tension with" }, { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Conflicts with" }, { "description": "[Uniform Interface](/records/architecture/uniform-interface), [Predictability](/records/architecture/predictability), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" }, { "description": "[Human Factors](/records/algorithms/human-factors)", "term": "Contracts" }, { "description": "[Principle of Least Surprise / Clever Abstractions](/records/tension/clever-abstractions-principle-of-least-surprise)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Violated by" }, { "description": "misleading names, [hidden behavior](/records/lexicon/hidden-behavior)", "term": "Detected by" }, { "description": "surprise defects, misuse reports", "term": "Measured by" }, { "description": "[Name the Concept](/records/lexicon/name-the-concept), [Make Effects Explicit](/records/lexicon/make-effects-explicit), [Standardize the Interface](/records/lexicon/standardize-the-interface)", "term": "Refactored by" }, { "description": "API review, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function getFoo(id: FooId) {\n fooStore.delete(id);\n return undefined;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function getFoo(id: FooId) { return fooStore.find(id); }\nfunction deleteFoo(id: FooId) { return fooStore.delete(id); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "API review, tests", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Predictability](/records/architecture/predictability), [Convention](/records/lexicon/convention), [Stable Interfaces](/records/architecture/stable-interfaces), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Safe Use](/records/lexicon/safe-use)", "term": "Depends on" }, { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-principle-of-least-surprise", "title": "Principle of Least Surprise" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/architecture-category/schema-canonical-data-semantics)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: schema, data modeling, integrity", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for decomposing tables by their functional dependencies into normal forms, so no column depends on anything but its key.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Functional Dependencies](/records/lexicon/functional-dependencies)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Data Integrity](/records/lexicon/data-integrity)", "term": "Reinforces" }, { "description": "[Non-Redundant Storage](/records/lexicon/non-redundant-storage), [Non-Redundant Storage](/records/lexicon/non-redundant-storage)", "term": "Enables" }, { "description": "[Read Performance](/records/lexicon/read-performance)", "term": "In tension with" }, { "description": "[Duplicated Denormalized Columns](/records/lexicon/duplicated-denormalized-columns)", "term": "Conflicts with" }, { "description": "[Database Normalization / Read Performance](/records/tension/database-normalization-read-performance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Duplicated Denormalized Columns](/records/lexicon/duplicated-denormalized-columns)", "term": "Violated by" }, { "description": "the same fact stored in multiple places drifting out of sync", "term": "Detected by" }, { "description": "update-anomaly incidents and redundant-column count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "schema review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "type FooRow = { id: string; customerName: string; customerCity: string; customerCityZip: string };", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type Foo = { id: FooId; customerId: CustomerId };\ntype Customer = { id: CustomerId; name: string; cityId: CityId };\ntype City = { id: CityId; name: string; zip: string };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "schema review", "term": "Checked by" }, { "description": "Every schema, type, name and stored fact that represents one concept", "term": "Population" }, { "description": "A verdict stands until a schema, a type or a stored representation changes", "term": "Freshness" }, { "description": "The type checker, schema registry or validation pipeline fails a representation that diverges from the canonical one", "term": "Refusal" }, { "description": "Schemas and types compared across producers, stores and consumers of the same concept", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The canonical representation, which every producer, store and consumer conforms to", "term": "Authoritative side" }, { "description": "[Functional Dependencies](/records/lexicon/functional-dependencies), [Single Source of Truth](/records/architecture/single-source-of-truth), [Data Integrity](/records/lexicon/data-integrity), [Non-Redundant Storage](/records/lexicon/non-redundant-storage), [Non-Redundant Storage](/records/lexicon/non-redundant-storage)", "term": "Depends on" }, { "description": "[Duplicated Denormalized Columns](/records/lexicon/duplicated-denormalized-columns)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-database-normalization", "title": "Database Normalization" } ], "title": "Schema / Canonical Data / Semantics" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_security_by_design[\"Security by Design\"]\n n_defense_in_depth[\"Defense in Depth\"]\n n_least_privilege[\"Least Privilege\"]\n n_zero_trust_architecture[\"Zero Trust Architecture\"]\n n_secure_by_default[\"Secure by Default\"]\n n_attack_surface_reduction[\"Attack Surface Reduction\"]\n n_threat_modeling[\"Threat Modeling\"]\n n_authentication[\"Authentication\"]\n n_authorization[\"Authorization\"]\n n_access_control[\"Access Control\"]\n n_role_based_access_control[\"Role-Based Access Control (RBAC)\"]\n n_attribute_based_access_control[\"Attribute-Based Access Control (ABAC)\"]\n n_input_validation[\"Input Validation\"]\n n_output_encoding[\"Output Encoding\"]\n n_encryption_at_rest[\"Encryption at Rest\"]\n n_encryption_in_transit[\"Encryption in Transit\"]\n n_secrets_management[\"Secrets Management\"]\n n_privacy_by_design[\"Privacy by Design\"]\n n_compliance[\"Compliance\"]\n n_governance[\"Governance\"]\n n_policy_enforcement[\"Policy Enforcement\"]\n n_policy_as_code[\"Policy as Code\"]\n n_risk_management[\"Risk Management\"]\n n_continuous_compliance[\"Continuous Compliance\"]\n n_csrf_protection[\"CSRF Protection\"]\n n_parameterized_queries[\"Parameterized Queries\"]\n n_session_management[\"Session Management\"]\n n_security_by_design --> n_threat_modeling\n n_security_by_design --> n_secure_by_default\n n_security_by_design --> n_defense_in_depth\n n_security_by_design --> n_compliance\n n_defense_in_depth --> n_security_by_design\n n_least_privilege --> n_access_control\n n_least_privilege --> n_zero_trust_architecture\n n_zero_trust_architecture --> n_least_privilege\n n_attack_surface_reduction --> n_security_by_design\n n_threat_modeling --> n_security_by_design\n n_threat_modeling --> n_risk_management\n n_authentication --> n_access_control\n n_authorization --> n_least_privilege\n n_access_control --> n_least_privilege\n n_role_based_access_control --> n_access_control\n n_privacy_by_design --> n_compliance\n n_compliance --> n_governance\n n_compliance --> n_risk_management\n n_governance --> n_compliance\n n_policy_enforcement --> n_compliance\n n_policy_as_code --> n_continuous_compliance\n n_risk_management --> n_compliance\n n_risk_management --> n_security_by_design\n n_continuous_compliance --> n_policy_as_code\n n_continuous_compliance --> n_compliance\n n_csrf_protection --> n_authentication\n n_csrf_protection --> n_defense_in_depth\n n_parameterized_queries --> n_input_validation\n n_parameterized_queries --> n_secure_by_default\n n_session_management --> n_authentication\n n_session_management --> n_access_control\n n_session_management --> n_least_privilege" } ], "icon": "bi-collection", "id": "architecture-category-security-privacy-compliance-governance", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: system, service, codebase", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that threats are modeled and controls built into every component from its first design.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Threat Modeling](/records/architecture/threat-modeling), [Secure by Default](/records/architecture/secure-by-default)", "term": "Requires" }, { "description": "[Defense in Depth](/records/architecture/defense-in-depth), [Compliance](/records/architecture/compliance)", "term": "Reinforces" }, { "description": "[Proactive Risk Reduction](/records/lexicon/proactive-risk-reduction)", "term": "Enables" }, { "description": "[Developer Ergonomics](/records/lexicon/developer-ergonomics)", "term": "In tension with" }, { "description": "[Security as Afterthought](/records/lexicon/security-as-afterthought)", "term": "Conflicts with" }, { "description": "[Fail Secure](/records/architecture/fail-secure), [Defense in Depth](/records/architecture/defense-in-depth), [Attack Surface Reduction](/records/architecture/attack-surface-reduction), [Threat Modeling](/records/architecture/threat-modeling), [Risk Management](/records/architecture/risk-management)", "term": "Referenced by" }, { "description": "[Security Core](/records/algorithms/security-core)", "term": "Contracts" }, { "description": "[Security by Design / Developer Ergonomics](/records/tension/developer-ergonomics-security-by-design)", "term": "Tensions" }, { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction): Security by design builds controls in from the first design, while attack surface reduction removes what nothing uses.", "term": "Distinct from" }, { "description": "[Fail Secure](/records/architecture/fail-secure): Security by design is the approach to every component, while fail secure is one rule, that a failed check denies access.", "term": "Distinct from" }, { "description": "[Defense in Depth](/records/architecture/defense-in-depth): Security by design puts controls in from the start, while defense in depth layers several independent controls on each asset.", "term": "Distinct from" }, { "description": "[Secure by Default](/records/architecture/secure-by-default): Security by design shapes the whole design, while secure by default fixes the state its settings ship in.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Security as Afterthought](/records/lexicon/security-as-afterthought)", "term": "Violated by" }, { "description": "missing authz/input validation/threat model", "term": "Detected by" }, { "description": "security control coverage", "term": "Measured by" }, { "description": "[Trust Boundaries](/records/lexicon/trust-boundaries), [Input Validation](/records/architecture/input-validation), [Access Control](/records/architecture/access-control)", "term": "Refactored by" }, { "description": "security gates, [policy-as-code](/records/architecture/policy-as-code)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFoo(request: Request) {\n return fooStore.save(request.body as Foo);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function createFoo(request: Request, identity: Identity) {\n const input = CreateFooSchema.parse(request.body);\n authorize(identity, \"foo:create\");\n return fooStore.save(Foo.create(input));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security gates, policy-as-code", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Threat Modeling](/records/architecture/threat-modeling), [Secure by Default](/records/architecture/secure-by-default), [Defense in Depth](/records/architecture/defense-in-depth), [Compliance](/records/architecture/compliance), [Proactive Risk Reduction](/records/lexicon/proactive-risk-reduction)", "term": "Depends on" }, { "description": "[Security as Afterthought](/records/lexicon/security-as-afterthought)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-security-by-design", "title": "Security by Design" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: system, infrastructure, application", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that several independent security controls protect each asset, so one failed control does not expose it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Layered Controls](/records/lexicon/layered-controls)", "term": "Requires" }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Reinforces" }, { "description": "[Compromise Containment](/records/lexicon/compromise-containment)", "term": "Enables" }, { "description": "[Complexity](/records/lexicon/complexity)", "term": "In tension with" }, { "description": "[Single Control Reliance](/records/lexicon/single-control-reliance)", "term": "Conflicts with" }, { "description": "[Security by Design](/records/architecture/security-by-design), [CSRF Protection](/records/architecture/csrf-protection)", "term": "Referenced by" }, { "description": "[Defense in Depth / Complexity](/records/tension/complexity-defense-in-depth)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Control Reliance](/records/lexicon/single-control-reliance)", "term": "Violated by" }, { "description": "missing secondary control", "term": "Detected by" }, { "description": "control depth", "term": "Measured by" }, { "description": "[Controls](/records/lexicon/controls)", "term": "Refactored by" }, { "description": "threat model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo\", createFoo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.post(\"/foo\",\n authenticate(),\n authorize(\"foo:create\"),\n validate(CreateFooSchema),\n rateLimit({ limit: 100 }),\n audit(\"FOO_CREATE\"),\n createFoo,\n);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "threat model review", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Layered Controls](/records/lexicon/layered-controls), [Security by Design](/records/architecture/security-by-design), [Compromise Containment](/records/lexicon/compromise-containment)", "term": "Depends on" }, { "description": "[Single Control Reliance](/records/lexicon/single-control-reliance)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-defense-in-depth", "title": "Defense in Depth" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: user, service, process, data", "Aliases: Principle of Least Privilege, PoLP", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each user, service and process holds only the permissions its task needs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Access Control](/records/architecture/access-control), [Minimal Permissions](/records/lexicon/minimal-permissions)", "term": "Requires" }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture), [Damage Limitation](/records/lexicon/damage-limitation)", "term": "Reinforces" }, { "description": "[Reduced Blast Radius](/records/lexicon/reduced-blast-radius)", "term": "Enables" }, { "description": "[Operational Convenience](/records/lexicon/operational-convenience)", "term": "In tension with" }, { "description": "[Broad Admin Access](/records/lexicon/broad-admin-access)", "term": "Conflicts with" }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture), [Authorization](/records/architecture/authorization), [Access Control](/records/architecture/access-control), [Session Management](/records/architecture/session-management)", "term": "Referenced by" }, { "description": "[Least Privilege Over Broad Privilege](/records/algorithms/no-broad-privilege)", "term": "Contracts" }, { "description": "[Least Privilege / Operational Convenience](/records/tension/least-privilege-operational-convenience)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Broad Admin Access](/records/lexicon/broad-admin-access)", "term": "Violated by" }, { "description": "overbroad roles/scopes", "term": "Detected by" }, { "description": "privilege excess count", "term": "Measured by" }, { "description": "[Least-Privilege Credential](/records/lexicon/least-privilege-credential)", "term": "Refactored by" }, { "description": "IAM policy checks", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooJob {\n constructor(private readonly db: AdminDatabase) {}\n run(foo: Foo) { return this.db.execute(`insert into foo values (?)`, foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface FooWriter { insert(foo: Foo): Promise; }\nclass FooJob {\n constructor(private readonly foos: FooWriter) {}\n run(foo: Foo) { return this.foos.insert(foo); }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "IAM policy checks", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Access Control](/records/architecture/access-control), [Minimal Permissions](/records/lexicon/minimal-permissions), [Zero Trust Architecture](/records/architecture/zero-trust-architecture), [Damage Limitation](/records/lexicon/damage-limitation), [Reduced Blast Radius](/records/lexicon/reduced-blast-radius)", "term": "Depends on" }, { "description": "[Broad Admin Access](/records/lexicon/broad-admin-access)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-least-privilege", "title": "Least Privilege" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, network, identity", "Aliases: Zero Trust", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of authenticating and authorizing every request on its own identity and context, whatever network it comes from.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Strong Identity](/records/lexicon/strong-identity), [Continuous Authorization](/records/lexicon/continuous-authorization)", "term": "Requires" }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Reinforces" }, { "description": "[Perimeterless Security](/records/lexicon/perimeterless-security)", "term": "Enables" }, { "description": "[Latency/Complexity](/records/lexicon/latency-complexity)", "term": "In tension with" }, { "description": "[Trusted Internal Network Assumption](/records/lexicon/trusted-internal-network-assumption)", "term": "Conflicts with" }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" }, { "description": "[Zero Trust](/records/lexicon/zero-trust)", "term": "Term" }, { "description": "[Zero Trust Architecture / Latency/Complexity](/records/tension/latency-complexity-zero-trust-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Trusted Internal Network Assumption](/records/lexicon/trusted-internal-network-assumption)", "term": "Violated by" }, { "description": "internal endpoints without authz/authn", "term": "Detected by" }, { "description": "trustless control coverage", "term": "Measured by" }, { "description": "[Authentication](/records/architecture/authentication), [Authorization](/records/architecture/authorization), [Network Segmentation](/records/lexicon/network-segmentation)", "term": "Refactored by" }, { "description": "[policy-as-code](/records/architecture/policy-as-code), gateway rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (request.network === \"internal\") return createFoo(request.body);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const identity = authenticate(request.credentials);\nauthorize(identity, \"foo:create\", { resource: request.body.id });\nverifyDevice(request.deviceAttestation);\nreturn createFoo(CreateFooSchema.parse(request.body));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy-as-code, gateway rules", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Strong Identity](/records/lexicon/strong-identity), [Continuous Authorization](/records/lexicon/continuous-authorization), [Least Privilege](/records/architecture/least-privilege), [Perimeterless Security](/records/lexicon/perimeterless-security)", "term": "Depends on" }, { "description": "[Trusted Internal Network Assumption](/records/lexicon/trusted-internal-network-assumption)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-zero-trust-architecture", "title": "Zero Trust Architecture" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: configuration, API, product", "Aliases: Secure Defaults", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every setting ships in its most restrictive safe state, and weakening one requires an explicit opt-in.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Safe Defaults](/records/lexicon/safe-defaults)", "term": "Requires" }, { "description": "[Fail Secure](/records/architecture/fail-secure)", "term": "Reinforces" }, { "description": "[Reduced Misconfiguration Risk](/records/lexicon/reduced-misconfiguration-risk)", "term": "Enables" }, { "description": "[Ease of Initial Use](/records/lexicon/ease-of-initial-use)", "term": "In tension with" }, { "description": "[Insecure Defaults](/records/lexicon/insecure-defaults)", "term": "Conflicts with" }, { "description": "[Fail Secure](/records/architecture/fail-secure), [Security by Design](/records/architecture/security-by-design), [Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" }, { "description": "[Secure by Default / Ease of Initial Use](/records/tension/ease-of-initial-use-secure-by-default)", "term": "Tensions" }, { "description": "[Fail Secure](/records/architecture/fail-secure): Secure by default is the state settings ship in, while fail secure is the state a failed check leaves access in.", "term": "Distinct from" }, { "description": "[Safe Defaults](/records/lexicon/safe-defaults): Secure by default restricts access in the shipped settings, while safe defaults avoid harm in the shipped behavior.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Insecure Defaults](/records/lexicon/insecure-defaults)", "term": "Violated by" }, { "description": "insecure default config", "term": "Detected by" }, { "description": "insecure default count", "term": "Measured by" }, { "description": "[Default Deny](/records/lexicon/default-deny)", "term": "Refactored by" }, { "description": "config policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooApi = createApi({ public: true, tls: false, audit: false });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooApi = createApi({\n public: false,\n tls: \"required\",\n authentication: \"required\",\n audit: true,\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "config policy", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Safe Defaults](/records/lexicon/safe-defaults), [Fail Secure](/records/architecture/fail-secure), [Reduced Misconfiguration Risk](/records/lexicon/reduced-misconfiguration-risk)", "term": "Depends on" }, { "description": "[Insecure Defaults](/records/lexicon/insecure-defaults)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-secure-by-default", "title": "Secure by Default" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, service, infrastructure", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that endpoints, ports, features and permissions nothing uses are removed or disabled.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Minimal Exposure](/records/lexicon/minimal-exposure)", "term": "Requires" }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Reinforces" }, { "description": "[Reduced Exploitability](/records/lexicon/reduced-exploitability)", "term": "Enables" }, { "description": "[Feature Exposure](/records/lexicon/feature-exposure)", "term": "In tension with" }, { "description": "[Unnecessary Public Surface](/records/lexicon/unnecessary-public-surface)", "term": "Conflicts with" }, { "description": "[Attack Surface Reduction / Feature Exposure](/records/tension/attack-surface-reduction-feature-exposure)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unnecessary Public Surface](/records/lexicon/unnecessary-public-surface)", "term": "Violated by" }, { "description": "exposed unused routes/services", "term": "Detected by" }, { "description": "exposed surface count", "term": "Measured by" }, { "description": "[Restrict Exports](/records/lexicon/restrict-exports), [Access Control](/records/architecture/access-control), [Feature Toggle](/records/architecture/feature-toggle)", "term": "Refactored by" }, { "description": "attack surface scanning", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.enableDebugConsole();\napp.exposeAdminApi();\napp.loadAllPlugins();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.register(fooPublicApi);\napp.disable(\"debug-console\");\napp.disable(\"admin-api\");\napp.loadPlugins(approvedFooPlugins);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "attack surface scanning", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Minimal Exposure](/records/lexicon/minimal-exposure), [Security by Design](/records/architecture/security-by-design), [Reduced Exploitability](/records/lexicon/reduced-exploitability)", "term": "Depends on" }, { "description": "[Unnecessary Public Surface](/records/lexicon/unnecessary-public-surface)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-attack-surface-reduction", "title": "Attack Surface Reduction" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: sensitive systems", "Scope: feature, system, architecture", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of listing a flow's assets, trust boundaries and threats, and choosing a mitigation for each threat.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Assets](/records/lexicon/assets), [Trust Boundaries](/records/lexicon/trust-boundaries), [Threat Scenarios](/records/lexicon/threat-scenarios)", "term": "Requires" }, { "description": "[Security by Design](/records/architecture/security-by-design), [Risk Management](/records/architecture/risk-management)", "term": "Reinforces" }, { "description": "[Control Selection](/records/lexicon/control-selection)", "term": "Enables" }, { "description": "[Delivery Speed](/records/lexicon/delivery-speed)", "term": "In tension with" }, { "description": "[Assumption-Driven Security](/records/lexicon/assumption-driven-security), [Security Theater](/records/architecture/security-theater)", "term": "Conflicts with" }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Referenced by" }, { "description": "[Threat Modeling / Delivery Speed](/records/tension/delivery-speed-threat-modeling)", "term": "Tensions" }, { "description": "[Control Selection](/records/lexicon/control-selection): Threat modeling lists the assets, boundaries and threats, while control selection chooses the controls that answer them.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Assumption-Driven Security](/records/lexicon/assumption-driven-security)", "term": "Violated by" }, { "description": "missing threat model for sensitive flow", "term": "Detected by" }, { "description": "threat model coverage", "term": "Measured by" }, { "description": "[Mitigation Plan](/records/lexicon/mitigation-plan)", "term": "Refactored by" }, { "description": "security review gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "designFooUpload();\nshipFooUpload();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const threats = modelThreats(fooUploadFlow, [\"spoofing\", \"tampering\", \"repudiation\", \"disclosure\", \"denial\", \"elevation\"]);\nfor (const threat of threats) requireMitigation(threat);\nshipFooUpload();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security review gates", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Assets](/records/lexicon/assets), [Trust Boundaries](/records/lexicon/trust-boundaries), [Threat Scenarios](/records/lexicon/threat-scenarios), [Security by Design](/records/architecture/security-by-design), [Risk Management](/records/architecture/risk-management), [Control Selection](/records/lexicon/control-selection)", "term": "Depends on" }, { "description": "[Assumption-Driven Security](/records/lexicon/assumption-driven-security), [Security Theater](/records/architecture/security-theater)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-threat-modeling", "title": "Threat Modeling" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: user, service, API", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that verifies a caller's claimed identity from a credential before any protected action runs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Identity Proof](/records/lexicon/identity-proof)", "term": "Requires" }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Reinforces" }, { "description": "[Identity-Aware Authorization](/records/lexicon/identity-aware-authorization)", "term": "Enables" }, { "description": "[User Experience](/records/lexicon/user-experience)", "term": "In tension with" }, { "description": "[Anonymous Sensitive Access](/records/lexicon/anonymous-sensitive-access)", "term": "Conflicts with" }, { "description": "[CSRF Protection](/records/architecture/csrf-protection), [Session Management](/records/architecture/session-management)", "term": "Referenced by" }, { "description": "[Authentication / User Experience](/records/tension/authentication-user-experience)", "term": "Tensions" }, { "description": "[Access Control](/records/architecture/access-control): Authentication verifies who the caller is, while access control decides what that caller may do.", "term": "Distinct from" }, { "description": "[CSRF Protection](/records/architecture/csrf-protection): Authentication verifies an identity, while CSRF protection verifies that a request came from the site's own pages.", "term": "Distinct from" }, { "description": "[Session Management](/records/architecture/session-management): Authentication verifies a credential once, while session management keeps the result across requests.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Anonymous Sensitive Access](/records/lexicon/anonymous-sensitive-access)", "term": "Violated by" }, { "description": "unauthenticated protected endpoints", "term": "Detected by" }, { "description": "auth coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "route policies, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const userId = request.headers.get(\"X-User-ID\");\nreturn loadFooFor(userId!);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const credential = requireHeader(request, \"Authorization\");\nconst identity = await authenticator.verify(credential);\nif (!identity) throw new UnauthorizedError();\nreturn loadFooFor(identity.subject);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "route policies, tests", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Identity Proof](/records/lexicon/identity-proof), [Access Control](/records/architecture/access-control), [Identity-Aware Authorization](/records/lexicon/identity-aware-authorization)", "term": "Depends on" }, { "description": "[Anonymous Sensitive Access](/records/lexicon/anonymous-sensitive-access)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-authentication", "title": "Authentication" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, domain action, data access", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that decides, from a policy, whether an authenticated principal may perform an action on a resource.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Authenticated Principal](/records/lexicon/authenticated-principal), [Policy](/records/lexicon/policy)", "term": "Requires" }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Reinforces" }, { "description": "[Controlled Access](/records/lexicon/controlled-access)", "term": "Enables" }, { "description": "[Policy Complexity](/records/lexicon/policy-complexity)", "term": "In tension with" }, { "description": "[Authenticated-Equals-Authorized](/records/lexicon/authenticated-equals-authorized), [Authorization Scattering](/records/architecture/authorization-scattering)", "term": "Conflicts with" }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Referenced by" }, { "description": "[Authorization / Policy Complexity](/records/tension/authorization-policy-complexity)", "term": "Tensions" }, { "description": "[Remote Stub](/records/lexicon/remote-stub): Authorization decides whether a principal may act, while a remote stub forwards calls to an object in another process.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unrestricted Access](/records/lexicon/unrestricted-access)", "term": "Violated by" }, { "description": "protected operation without authz guard", "term": "Detected by" }, { "description": "authorization coverage", "term": "Measured by" }, { "description": "[Policy Enforcement](/records/architecture/policy-enforcement), [Centralize Policy](/records/lexicon/centralize-policy)", "term": "Refactored by" }, { "description": "security tests, [policy-as-code](/records/architecture/policy-as-code)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const identity = authenticate(request);\nreturn fooStore.delete(request.params.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const identity = authenticate(request);\nauthorize(identity, \"foo:delete\", { fooId: request.params.id });\nreturn fooStore.delete(request.params.id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security tests, policy-as-code", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Authenticated Principal](/records/lexicon/authenticated-principal), [Policy](/records/lexicon/policy), [Least Privilege](/records/architecture/least-privilege), [Controlled Access](/records/lexicon/controlled-access)", "term": "Depends on" }, { "description": "[Authenticated-Equals-Authorized](/records/lexicon/authenticated-equals-authorized), [Authorization Scattering](/records/architecture/authorization-scattering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-authorization", "title": "Authorization" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, data, infrastructure", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that evaluates an access policy for each request to a resource and denies the request when the policy does not allow it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Authorization Policy](/records/lexicon/authorization-policy)", "term": "Requires" }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Reinforces" }, { "description": "[Resource Protection](/records/lexicon/resource-protection)", "term": "Enables" }, { "description": "[Usability](/records/lexicon/usability)", "term": "In tension with" }, { "description": "[Unrestricted Access](/records/lexicon/unrestricted-access)", "term": "Conflicts with" }, { "description": "[Centralized Configuration](/records/architecture/centralized-configuration), [Least Privilege](/records/architecture/least-privilege), [Authentication](/records/architecture/authentication), [Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control), [Session Management](/records/architecture/session-management)", "term": "Referenced by" }, { "description": "[Access Control / Usability](/records/tension/access-control-usability)", "term": "Tensions" }, { "description": "[Session Management](/records/architecture/session-management): Access control evaluates a policy per request, while session management keeps the authenticated session the request carries.", "term": "Distinct from" }, { "description": "[Config Store](/records/lexicon/config-store): Access control decides who may reach a resource, while a config store is one such resource, holding configuration for many services.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unrestricted Access](/records/lexicon/unrestricted-access)", "term": "Violated by" }, { "description": "resource endpoint lacking policy", "term": "Detected by" }, { "description": "access control coverage", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "policy tests", "term": "Enforced by" }, { "description": "access-control", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "if (user.role === \"admin\") return fooStore.findAll();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const decision = accessPolicy.evaluate({\n subject: user,\n action: \"foo:list\",\n resource: { tenantId: request.tenantId },\n});\nif (!decision.allowed) throw new ForbiddenError();\nreturn fooStore.findAll(request.tenantId);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy tests", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Authorization Policy](/records/lexicon/authorization-policy), [Least Privilege](/records/architecture/least-privilege), [Resource Protection](/records/lexicon/resource-protection)", "term": "Depends on" }, { "description": "[Unrestricted Access](/records/lexicon/unrestricted-access)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-access-control", "title": "Access Control" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: user, role, resource", "Aliases: RBAC", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of access control, Role-Based Access Control (RBAC), in which permissions attach to roles and users receive roles.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Role Definitions](/records/lexicon/role-definitions)", "term": "Requires" }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Reinforces" }, { "description": "[Coarse-Grained Permission Management](/records/lexicon/coarse-grained-permission-management)", "term": "Enables" }, { "description": "[Role Explosion](/records/lexicon/role-explosion)", "term": "In tension with" }, { "description": "[Ad-Hoc Permission Checks](/records/lexicon/ad-hoc-permission-checks)", "term": "Conflicts with" }, { "description": "[Role-Based Access Control (RBAC) / Role Explosion](/records/tension/role-based-access-control-rbac-role-explosion)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Rules](/records/lexicon/hardcoded-rules)", "term": "Violated by" }, { "description": "scattered role checks", "term": "Detected by" }, { "description": "role-policy consistency", "term": "Measured by" }, { "description": "[Centralize Policy](/records/lexicon/centralize-policy)", "term": "Refactored by" }, { "description": "[authorization tests](/records/lexicon/authorization-tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (user.name === \"Developer\") allowDeleteFoo();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const roles = new Map([\n [\"foo-reader\", [\"foo:read\"]],\n [\"foo-editor\", [\"foo:read\", \"foo:write\"]],\n [\"foo-admin\", [\"foo:read\", \"foo:write\", \"foo:delete\"]],\n]);\nauthorizeRole(user.roles, \"foo:delete\", roles);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "authorization tests", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Role Definitions](/records/lexicon/role-definitions), [Access Control](/records/architecture/access-control), [Coarse-Grained Permission Management](/records/lexicon/coarse-grained-permission-management)", "term": "Depends on" }, { "description": "[Ad-Hoc Permission Checks](/records/lexicon/ad-hoc-permission-checks)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-role-based-access-control", "title": "Role-Based Access Control (RBAC)" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: user, resource, context", "Aliases: ABAC", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of access control, Attribute-Based Access Control (ABAC), in which a policy decides from attributes of the subject, the resource and the environment.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Attribute Definitions](/records/lexicon/attribute-definitions), [Policy Engine](/records/lexicon/policy-engine)", "term": "Requires" }, { "description": "[Fine-Grained Access Control](/records/lexicon/fine-grained-access-control)", "term": "Reinforces" }, { "description": "[Context-Aware Authorization](/records/lexicon/context-aware-authorization)", "term": "Enables" }, { "description": "[Policy Complexity](/records/lexicon/policy-complexity)", "term": "In tension with" }, { "description": "[Hardcoded Rules](/records/lexicon/hardcoded-rules)", "term": "Conflicts with" }, { "description": "[Attribute-Based Access Control (ABAC) / Policy Complexity](/records/tension/attribute-based-access-control-abac-policy-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hardcoded Rules](/records/lexicon/hardcoded-rules)", "term": "Violated by" }, { "description": "duplicated attribute checks in handlers", "term": "Detected by" }, { "description": "policy centralization", "term": "Measured by" }, { "description": "[Policy as Code](/records/architecture/policy-as-code), [Policy Engine](/records/lexicon/policy-engine)", "term": "Refactored by" }, { "description": "[policy-as-code](/records/architecture/policy-as-code)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (user.role === \"editor\") return updateFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const decision = policy.evaluate({\n subject: { id: user.id, department: user.department },\n action: \"foo:update\",\n resource: { ownerId: foo.ownerId, classification: foo.classification },\n environment: { time: clock.now() },\n});\nif (!decision.allowed) throw new ForbiddenError();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy-as-code", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Attribute Definitions](/records/lexicon/attribute-definitions), [Policy Engine](/records/lexicon/policy-engine), [Fine-Grained Access Control](/records/lexicon/fine-grained-access-control), [Context-Aware Authorization](/records/lexicon/context-aware-authorization)", "term": "Depends on" }, { "description": "[Hardcoded Rules](/records/lexicon/hardcoded-rules)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-attribute-based-access-control", "title": "Attribute-Based Access Control (ABAC)" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, boundary, function", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that checks external input against a schema at the boundary before core logic uses it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Validation Rules](/records/lexicon/validation-rules), [Schema](/records/lexicon/schema)", "term": "Requires" }, { "description": "[Security](/records/lexicon/security), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Fail Fast](/records/architecture/fail-fast)", "term": "Enables" }, { "description": "[Input Flexibility](/records/lexicon/input-flexibility)", "term": "In tension with" }, { "description": "[Trusting External Input](/records/lexicon/trusting-external-input)", "term": "Conflicts with" }, { "description": "[Preconditions](/records/architecture/preconditions), [Defensive Programming](/records/architecture/defensive-programming), [Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" }, { "description": "[Boundary Validation Over Unvalidated Input](/records/algorithms/no-unvalidated-input)", "term": "Contracts" }, { "description": "[Input Validation / Input Flexibility](/records/tension/input-flexibility-input-validation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Trusting External Input](/records/lexicon/trusting-external-input)", "term": "Violated by" }, { "description": "missing boundary validators", "term": "Detected by" }, { "description": "validation coverage", "term": "Measured by" }, { "description": "[Schema Validation](/records/architecture/schema-validation)", "term": "Refactored by" }, { "description": "validation middleware, [tests](/records/lexicon/tests)", "term": "Enforced by" }, { "description": "input-validation", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "const input = request.body as Foo;\nfooStore.save(input);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const input = CreateFooSchema.parse(request.body);\nfooStore.save(input);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "validation middleware, tests", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Validation Rules](/records/lexicon/validation-rules), [Schema](/records/lexicon/schema), [Security](/records/lexicon/security), [Correctness](/records/architecture/correctness), [Fail Fast](/records/architecture/fail-fast)", "term": "Depends on" }, { "description": "[Trusting External Input](/records/lexicon/trusting-external-input)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-input-validation", "title": "Input Validation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: UI, API, serialization", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that escapes values for the context they are written into, such as HTML, SQL or a shell.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Context-Aware Encoding](/records/lexicon/context-aware-encoding)", "term": "Requires" }, { "description": "[Injection Prevention](/records/lexicon/injection-prevention)", "term": "Reinforces" }, { "description": "[Safe Rendering](/records/lexicon/safe-rendering)", "term": "Enables" }, { "description": "[Formatting Flexibility](/records/lexicon/formatting-flexibility)", "term": "In tension with" }, { "description": "[Raw Output Rendering](/records/lexicon/raw-output-rendering)", "term": "Conflicts with" }, { "description": "[Output Encoding / Formatting Flexibility](/records/tension/formatting-flexibility-output-encoding)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Raw Output Rendering](/records/lexicon/raw-output-rendering)", "term": "Violated by" }, { "description": "raw HTML/SQL/shell output paths", "term": "Detected by" }, { "description": "unsafe sink count", "term": "Measured by" }, { "description": "[Context-Aware Encoding](/records/lexicon/context-aware-encoding)", "term": "Refactored by" }, { "description": "security linting", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "response.html(`
${foo.name}`);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "response.html(`
${escapeHtml(foo.name)}`);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security linting", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Context-Aware Encoding](/records/lexicon/context-aware-encoding), [Injection Prevention](/records/lexicon/injection-prevention), [Safe Rendering](/records/lexicon/safe-rendering)", "term": "Depends on" }, { "description": "[Raw Output Rendering](/records/lexicon/raw-output-rendering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-output-encoding", "title": "Output Encoding" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: sensitive data", "Scope: storage, database, backups", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that encrypts stored data with managed keys, so the storage medium alone does not reveal it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Key Management](/records/lexicon/key-management)", "term": "Requires" }, { "description": "[Data Protection](/records/lexicon/data-protection)", "term": "Reinforces" }, { "description": "[Confidentiality of Stored Data](/records/lexicon/confidentiality-of-stored-data)", "term": "Enables" }, { "description": "[Key Operations](/records/lexicon/key-operations)", "term": "In tension with" }, { "description": "[Plaintext Sensitive Storage](/records/lexicon/plaintext-sensitive-storage)", "term": "Conflicts with" }, { "description": "[Encryption at Rest / Key Operations](/records/tension/encryption-at-rest-key-operations)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Plaintext Sensitive Storage](/records/lexicon/plaintext-sensitive-storage)", "term": "Violated by" }, { "description": "storage config scan", "term": "Detected by" }, { "description": "encrypted storage coverage", "term": "Measured by" }, { "description": "[Key Management](/records/lexicon/key-management)", "term": "Refactored by" }, { "description": "infrastructure policy", "term": "Enforced by" }, { "description": "encryption-at-rest", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "await disk.write(\"foos.json\", JSON.stringify(foos));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const ciphertext = await keyManager.encrypt(\"foo-data-key\", JSON.stringify(foos));\nawait disk.write(\"foos.enc\", ciphertext);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "infrastructure policy", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Key Management](/records/lexicon/key-management), [Data Protection](/records/lexicon/data-protection), [Confidentiality of Stored Data](/records/lexicon/confidentiality-of-stored-data)", "term": "Depends on" }, { "description": "[Plaintext Sensitive Storage](/records/lexicon/plaintext-sensitive-storage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-encryption-at-rest", "title": "Encryption at Rest" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: network, service communication", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that encrypts traffic between parties with TLS or mutual TLS and verifies the peer's certificate.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[TLS/mTLS](/records/lexicon/tls-mtls)", "term": "Requires" }, { "description": "[Confidentiality](/records/lexicon/confidentiality), [Integrity](/records/lexicon/integrity)", "term": "Reinforces" }, { "description": "[Secure Communication](/records/lexicon/secure-communication)", "term": "Enables" }, { "description": "[Certificate Management](/records/lexicon/certificate-management)", "term": "In tension with" }, { "description": "[Plaintext Transport](/records/lexicon/plaintext-transport)", "term": "Conflicts with" }, { "description": "[Encryption in Transit / Certificate Management](/records/tension/certificate-management-encryption-in-transit)", "term": "Tensions" }, { "description": "[TLS/mTLS](/records/lexicon/tls-mtls): Encryption in transit is the practice of encrypting traffic and verifying peers, while TLS and mutual TLS are the protocols that do it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Plaintext Transport](/records/lexicon/plaintext-transport)", "term": "Violated by" }, { "description": "HTTP/plain socket usage", "term": "Detected by" }, { "description": "encrypted transport coverage", "term": "Measured by" }, { "description": "[TLS/mTLS](/records/lexicon/tls-mtls)", "term": "Refactored by" }, { "description": "gateway/network policy", "term": "Enforced by" }, { "description": "encryption-in-transit", "term": "Refused by rules" } ], "kind": "glossary" }, { "code": "const client = new HttpClient(\"http://foo.internal\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const client = new HttpClient(\"https://foo.internal\", {\n tls: { minVersion: \"TLSv1.3\", verifyPeer: true },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "gateway/network policy", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[TLS/mTLS](/records/lexicon/tls-mtls), [Confidentiality](/records/lexicon/confidentiality), [Integrity](/records/lexicon/integrity), [Secure Communication](/records/lexicon/secure-communication)", "term": "Depends on" }, { "description": "[Plaintext Transport](/records/lexicon/plaintext-transport)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-encryption-in-transit", "title": "Encryption in Transit" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: config, deployment, runtime", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of keeping credentials in a secret store, reading them at runtime and rotating them on a schedule.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Secret Store](/records/lexicon/secret-store), [Rotation Policy](/records/lexicon/rotation-policy)", "term": "Requires" }, { "description": "[Secure Configuration](/records/lexicon/secure-configuration)", "term": "Reinforces" }, { "description": "[Safe Credential Handling](/records/lexicon/safe-credential-handling)", "term": "Enables" }, { "description": "[Operational Complexity](/records/lexicon/operational-complexity)", "term": "In tension with" }, { "description": "[Hardcoded Secrets](/records/lexicon/hardcoded-secrets), [Secret Sprawl](/records/architecture/secret-sprawl)", "term": "Conflicts with" }, { "description": "[Secret Store Over Hardcoded Secrets](/records/algorithms/no-hardcoded-secrets)", "term": "Contracts" }, { "description": "[Secrets Management / Operational Complexity](/records/tension/operational-complexity-secrets-management)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Secret Sprawl](/records/architecture/secret-sprawl), [Hardcoded Secrets](/records/lexicon/hardcoded-secrets)", "term": "Violated by" }, { "description": "secret scanning", "term": "Detected by" }, { "description": "secret exposure count", "term": "Measured by" }, { "description": "[Secret Rotation](/records/lexicon/secret-rotation)", "term": "Refactored by" }, { "description": "secret scans, CI gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const fooClient = new FooClient({ apiKey: \"foo_live_abc123\" });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const apiKey = await secretStore.read(\"services/foo/api-key\");\nif (!apiKey) throw new Error(\"missing foo api key\");\nconst fooClient = new FooClient({ apiKey });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "secret scans, CI gates", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Secret Store](/records/lexicon/secret-store), [Rotation Policy](/records/lexicon/rotation-policy), [Secure Configuration](/records/lexicon/secure-configuration), [Safe Credential Handling](/records/lexicon/safe-credential-handling)", "term": "Depends on" }, { "description": "[Hardcoded Secrets](/records/lexicon/hardcoded-secrets), [Secret Sprawl](/records/architecture/secret-sprawl)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-secrets-management", "title": "Secrets Management" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: systems holding personal data", "Scope: data, product, system", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that privacy protection is part of a system's design from its first version, covering which personal data it collects, how long it keeps it, who can see it and what its defaults expose.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Data Minimization](/records/lexicon/data-minimization), [Consent/Policy](/records/lexicon/consent-policy)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Security](/records/lexicon/security)", "term": "Reinforces" }, { "description": "[Privacy Compliance](/records/lexicon/privacy-compliance)", "term": "Enables" }, { "description": "[Analytics/Personalization](/records/lexicon/analytics-personalization)", "term": "In tension with" }, { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing)", "term": "Conflicts with" }, { "description": "[Privacy by Design / Analytics/Personalization](/records/tension/analytics-personalization-privacy-by-design)", "term": "Tensions" }, { "description": "[Data Minimization](/records/lexicon/data-minimization): Privacy by design covers collection, retention, visibility and defaults from the first version, while data minimization is its collection and retention part.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing)", "term": "Violated by" }, { "description": "personal-data flow without policy", "term": "Detected by" }, { "description": "personal-data surface, retention compliance", "term": "Measured by" }, { "description": "[Purpose Binding](/records/lexicon/purpose-binding), [Retention Policy](/records/lexicon/retention-policy)", "term": "Refactored by" }, { "description": "privacy review, [policy-as-code](/records/architecture/policy-as-code)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "auditLog.append({ user, request, foo, headers: request.headers });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "auditLog.append({\n actorId: pseudonymize(user.id),\n action: \"FOO_READ\",\n fooId: foo.id,\n purpose: \"support\",\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "privacy review, policy-as-code", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Data Minimization](/records/lexicon/data-minimization), [Consent/Policy](/records/lexicon/consent-policy), [Compliance](/records/architecture/compliance), [Security](/records/lexicon/security), [Privacy Compliance](/records/lexicon/privacy-compliance)", "term": "Depends on" }, { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing), [Personal Data Oversharing](/records/architecture/personal-data-oversharing)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-privacy-by-design", "title": "Privacy by Design" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: regulated systems", "Scope: system, organization, process", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a system implements the controls a regulation or standard requires, and keeps evidence of each one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Controls](/records/lexicon/controls), [Evidence](/records/lexicon/evidence), [Auditability](/records/architecture/auditability)", "term": "Requires" }, { "description": "[Governance](/records/architecture/governance), [Risk Management](/records/architecture/risk-management)", "term": "Reinforces" }, { "description": "[Regulatory Alignment](/records/lexicon/regulatory-alignment)", "term": "Enables" }, { "description": "[Delivery Speed](/records/lexicon/delivery-speed)", "term": "In tension with" }, { "description": "[Uncontrolled Change](/records/lexicon/uncontrolled-change)", "term": "Conflicts with" }, { "description": "[Reproducibility](/records/architecture/reproducibility), [Standards Compliance](/records/architecture/standards-compliance), [Model Governance](/records/architecture/model-governance), [Auditability](/records/architecture/auditability), [Security by Design](/records/architecture/security-by-design), [Privacy by Design](/records/architecture/privacy-by-design), [Governance](/records/architecture/governance), [Policy Enforcement](/records/architecture/policy-enforcement), [Risk Management](/records/architecture/risk-management), [Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" }, { "description": "[Compliance / Delivery Speed](/records/tension/compliance-delivery-speed)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Point-in-Time Audit Only](/records/lexicon/point-in-time-audit-only)", "term": "Violated by" }, { "description": "compliance gap assessment", "term": "Detected by" }, { "description": "control pass rate", "term": "Measured by" }, { "description": "[Controls](/records/lexicon/controls), [Evidence Citation](/records/lexicon/evidence-citation)", "term": "Refactored by" }, { "description": "compliance gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "storeFooData(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const classified = classify(foo);\nconst controls = compliance.requirements(classified, \"foo-storage\");\nawait enforceControls(controls);\nawait storeFooData(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "compliance gates", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Controls](/records/lexicon/controls), [Evidence](/records/lexicon/evidence), [Auditability](/records/architecture/auditability), [Governance](/records/architecture/governance), [Risk Management](/records/architecture/risk-management), [Regulatory Alignment](/records/lexicon/regulatory-alignment)", "term": "Depends on" }, { "description": "[Uncontrolled Change](/records/lexicon/uncontrolled-change)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-compliance", "title": "Compliance" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: organization, architecture, platform", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that architecture decisions are held to stated policies and standards, through review and automated gates.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Policy](/records/lexicon/policy), [Standards](/records/lexicon/standards), [Review](/records/lexicon/review)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Controlled Evolution](/records/lexicon/controlled-evolution)", "term": "Enables" }, { "description": "[Team Velocity](/records/lexicon/team-velocity)", "term": "In tension with" }, { "description": "[Unbounded Autonomy](/records/lexicon/unbounded-autonomy)", "term": "Conflicts with" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Versioning](/records/architecture/versioning), [Control Plane](/records/architecture/control-plane), [Centralized Configuration](/records/architecture/centralized-configuration), [Centralized Authentication](/records/architecture/centralized-authentication), [Decentralization](/records/architecture/decentralization), [Infrastructure as Code](/records/architecture/infrastructure-as-code), [Autonomy](/records/architecture/autonomy), [Assessment](/records/architecture/assessment), [Gap Analysis](/records/architecture/gap-analysis), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Architectural Consistency](/records/architecture/architectural-consistency), [Explainability](/records/architecture/explainability), [Single Source of Truth](/records/architecture/single-source-of-truth), [Compliance](/records/architecture/compliance)", "term": "Referenced by" }, { "description": "[Governance / Team Velocity](/records/tension/governance-team-velocity)", "term": "Tensions" }, { "description": "[Decentralization](/records/architecture/decentralization): Governance holds decisions to shared policy, while decentralization leaves them with the owning teams.", "term": "Distinct from" }, { "description": "[Standardization](/records/architecture/standardization): Governance reviews and gates decisions against policy, while standardization is one policy it can enforce, one choice per concern.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Uncontrolled Change](/records/lexicon/uncontrolled-change)", "term": "Violated by" }, { "description": "standard violations, undocumented decisions", "term": "Detected by" }, { "description": "policy compliance", "term": "Measured by" }, { "description": "[Standardize the Interface](/records/lexicon/standardize-the-interface), [Design Review](/records/architecture/design-review)", "term": "Refactored by" }, { "description": "architecture board, [policy-as-code](/records/architecture/policy-as-code)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "teams.defineFooApisIndependently();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const governance = defineArchitecturePolicy({\n apiVersioning: \"required\",\n schemaRegistry: \"required\",\n ownership: \"single-team\",\n});\narchitectureGate.enforce(governance);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture board, policy-as-code", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Policy](/records/lexicon/policy), [Standards](/records/lexicon/standards), [Review](/records/lexicon/review), [Compliance](/records/architecture/compliance), [Consistency](/records/architecture/consistency), [Controlled Evolution](/records/lexicon/controlled-evolution)", "term": "Depends on" }, { "description": "[Unbounded Autonomy](/records/lexicon/unbounded-autonomy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-governance", "title": "Governance" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: code, infrastructure, runtime", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that blocks an action a policy forbids at the point the action is attempted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Defined Policy](/records/lexicon/defined-policy)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Security](/records/lexicon/security)", "term": "Reinforces" }, { "description": "[Automated Control](/records/lexicon/automated-control)", "term": "Enables" }, { "description": "[False Positives](/records/lexicon/false-positives)", "term": "In tension with" }, { "description": "[Manual-Only Review](/records/lexicon/manual-only-review)", "term": "Conflicts with" }, { "description": "[Policy Enforcement / False Positives](/records/tension/false-positives-policy-enforcement)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Violated by" }, { "description": "policy drift", "term": "Detected by" }, { "description": "policy violation count", "term": "Measured by" }, { "description": "[Policy as Code](/records/architecture/policy-as-code), [Fitness Functions](/records/architecture/fitness-functions)", "term": "Refactored by" }, { "description": "CI/CD, runtime policy engine", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "if (!policyAllows(user, foo)) fooLog.record(\"policy violation\");\nreturn updateFoo(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (!policyAllows(user, foo)) throw new ForbiddenError();\nreturn updateFoo(foo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI/CD, runtime policy engine", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Defined Policy](/records/lexicon/defined-policy), [Compliance](/records/architecture/compliance), [Security](/records/lexicon/security), [Automated Control](/records/lexicon/automated-control)", "term": "Depends on" }, { "description": "[Manual-Only Review](/records/lexicon/manual-only-review)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-policy-enforcement", "title": "Policy Enforcement" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: infrastructure, deployment, security", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that expresses policies as machine-readable rules which a pipeline or policy engine evaluates automatically.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Machine-Readable Policies](/records/lexicon/machine-readable-policies)", "term": "Requires" }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Reinforces" }, { "description": "[Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Enables" }, { "description": "[Policy Maintenance](/records/lexicon/policy-maintenance)", "term": "In tension with" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Conflicts with" }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" }, { "description": "[Policy as Code / Policy Maintenance](/records/tension/policy-as-code-policy-maintenance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Manual-Only Review](/records/lexicon/manual-only-review)", "term": "Violated by" }, { "description": "missing policy rule for known control", "term": "Detected by" }, { "description": "automated policy coverage", "term": "Measured by" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Refactored by" }, { "description": "[policy engine](/records/lexicon/policy-engine)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "document.write(\"Only foo-admin may delete Foo\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooDeletePolicy = policy({\n action: \"foo:delete\",\n allow: input => input.subject.roles.includes(\"foo-admin\"),\n});\npolicyGate.enforce(fooDeletePolicy);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "policy engine", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Machine-Readable Policies](/records/lexicon/machine-readable-policies), [Continuous Compliance](/records/architecture/continuous-compliance), [Automated Enforcement](/records/lexicon/automated-enforcement)", "term": "Depends on" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance), [Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-policy-as-code", "title": "Policy as Code" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: architecture, security, delivery", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of identifying risks, rating their likelihood and impact, and assigning each one an owner and a mitigation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Risk Identification](/records/lexicon/risk-identification), [Mitigation](/records/lexicon/mitigation)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Security by Design](/records/architecture/security-by-design)", "term": "Reinforces" }, { "description": "[Priority-Based Controls](/records/lexicon/priority-based-controls)", "term": "Enables" }, { "description": "[Speed](/records/lexicon/speed)", "term": "In tension with" }, { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Conflicts with" }, { "description": "[Threat Modeling](/records/architecture/threat-modeling), [Compliance](/records/architecture/compliance)", "term": "Referenced by" }, { "description": "[Risk Management / Speed](/records/tension/risk-management-speed)", "term": "Tensions" }, { "description": "[Mitigation](/records/lexicon/mitigation): Risk management is the whole cycle of identifying, rating and owning risks, while mitigation is the step that reduces one.", "term": "Distinct from" }, { "description": "[Risk Identification](/records/lexicon/risk-identification): Risk management runs the whole cycle, while risk identification is its first step, finding the risks.", "term": "Distinct from" }, { "description": "[Threat Modeling](/records/architecture/threat-modeling): Risk management covers every kind of risk, while threat modeling covers the security threats to one flow.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Violated by" }, { "description": "risk register gaps", "term": "Detected by" }, { "description": "residual risk score", "term": "Measured by" }, { "description": "[Mitigation Plan](/records/lexicon/mitigation-plan), [Restrict Exports](/records/lexicon/restrict-exports)", "term": "Refactored by" }, { "description": "review gates", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "shipFooFeature();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const risk = assessRisk(fooFeature, {\n likelihood: 3,\n impact: 5,\n controls: [\"rate-limit\", \"audit\", \"rollback\"],\n});\nif (risk.residual > riskTolerance) throw new Error(\"risk not accepted\");\nshipFooFeature();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "review gates", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Risk Identification](/records/lexicon/risk-identification), [Mitigation](/records/lexicon/mitigation), [Compliance](/records/architecture/compliance), [Security by Design](/records/architecture/security-by-design), [Priority-Based Controls](/records/lexicon/priority-based-controls)", "term": "Depends on" }, { "description": "[Unowned Risk](/records/architecture/unowned-risk), [Unowned Risk](/records/architecture/unowned-risk)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-risk-management", "title": "Risk Management" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: CI/CD, infrastructure, codebase", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to check compliance on every change, with automated policy gates and evidence capture.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Policy as Code](/records/architecture/policy-as-code), [Evidence Automation](/records/lexicon/evidence-automation)", "term": "Requires" }, { "description": "[Compliance](/records/architecture/compliance), [Auditability](/records/architecture/auditability)", "term": "Reinforces" }, { "description": "[Ongoing Assurance](/records/lexicon/ongoing-assurance)", "term": "Enables" }, { "description": "[Pipeline Complexity](/records/lexicon/pipeline-complexity)", "term": "In tension with" }, { "description": "[Point-in-Time Audit Only](/records/lexicon/point-in-time-audit-only)", "term": "Conflicts with" }, { "description": "[Policy as Code](/records/architecture/policy-as-code)", "term": "Referenced by" }, { "description": "[Continuous Compliance / Pipeline Complexity](/records/tension/continuous-compliance-pipeline-complexity)", "term": "Tensions" }, { "description": "[Evidence Automation](/records/lexicon/evidence-automation): Continuous compliance checks every change against policy, while evidence automation collects the proof that the checks ran.", "term": "Distinct from" }, { "description": "[Ongoing Assurance](/records/lexicon/ongoing-assurance): Continuous compliance is checking on every change, while ongoing assurance is being able to show at any time that controls still work.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Point-in-Time Audit Only](/records/lexicon/point-in-time-audit-only)", "term": "Violated by" }, { "description": "missing automated compliance checks", "term": "Detected by" }, { "description": "continuous control pass rate", "term": "Measured by" }, { "description": "[Automated Enforcement](/records/lexicon/automated-enforcement), [Policy as Code](/records/architecture/policy-as-code)", "term": "Refactored by" }, { "description": "CI/CD controls", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "runComplianceAuditOncePerYear();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "pipeline.on(\"change\", async change => {\n const result = await complianceScanner.evaluate(change);\n if (!result.compliant) throw new ComplianceGateError(result.violations);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "CI/CD controls", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Policy as Code](/records/architecture/policy-as-code), [Evidence Automation](/records/lexicon/evidence-automation), [Compliance](/records/architecture/compliance), [Auditability](/records/architecture/auditability), [Ongoing Assurance](/records/lexicon/ongoing-assurance)", "term": "Depends on" }, { "description": "[Point-in-Time Audit Only](/records/lexicon/point-in-time-audit-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-continuous-compliance", "title": "Continuous Compliance" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: public APIs", "Scope: service, web, security", "Aliases: Cross-Site Request Forgery Protection", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that rejects state-changing requests which lack proof of coming from the site's own pages, such as an anti-forgery token.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Request Origin Verification](/records/lexicon/request-origin-verification)", "term": "Requires" }, { "description": "[Authentication](/records/architecture/authentication), [Defense in Depth](/records/architecture/defense-in-depth)", "term": "Reinforces" }, { "description": "[Forged-Request Rejection](/records/lexicon/forged-request-rejection)", "term": "Enables" }, { "description": "[Client Complexity](/records/lexicon/client-complexity)", "term": "In tension with" }, { "description": "[Ambient-Credential Trust](/records/lexicon/ambient-credential-trust)", "term": "Conflicts with" }, { "description": "[CSRF Protection / Client Complexity](/records/tension/client-complexity-csrf-protection)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ambient-Credential Trust](/records/lexicon/ambient-credential-trust)", "term": "Violated by" }, { "description": "no anti-forgery token on mutating endpoints", "term": "Detected by" }, { "description": "unprotected state-changing endpoint count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "security review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo/delete\", deleteFoo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.post(\"/foo/delete\", verifyCsrfToken(), requireSameSite(), deleteFoo);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security review", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Request Origin Verification](/records/lexicon/request-origin-verification), [Authentication](/records/architecture/authentication), [Defense in Depth](/records/architecture/defense-in-depth), [Forged-Request Rejection](/records/lexicon/forged-request-rejection)", "term": "Depends on" }, { "description": "[Ambient-Credential Trust](/records/lexicon/ambient-credential-trust)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-csrf-protection", "title": "CSRF Protection" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: service, database, security", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that sends query text and values to the database separately, so values are never parsed as query syntax.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Query Parameter Binding](/records/lexicon/query-parameter-binding)", "term": "Requires" }, { "description": "[Input Validation](/records/architecture/input-validation), [Secure by Default](/records/architecture/secure-by-default)", "term": "Reinforces" }, { "description": "[Injection-Safe Data Access](/records/lexicon/injection-safe-data-access)", "term": "Enables" }, { "description": "[Dynamic Query Flexibility](/records/lexicon/dynamic-query-flexibility)", "term": "In tension with" }, { "description": "[String-Concatenated SQL](/records/lexicon/string-concatenated-sql)", "term": "Conflicts with" }, { "description": "[Parameterized Queries / Dynamic Query Flexibility](/records/tension/dynamic-query-flexibility-parameterized-queries)", "term": "Tensions" }, { "description": "[Input Validation](/records/architecture/input-validation): Parameterized queries keep values out of query syntax whatever they contain, while input validation checks what values contain before use.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[String-Concatenated SQL](/records/lexicon/string-concatenated-sql)", "term": "Violated by" }, { "description": "string interpolation into query text", "term": "Detected by" }, { "description": "concatenated-query count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "security review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "db.query(`select * from foos where id = '${id}'`);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "db.query(\"select * from foos where id = $1\", [id]);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security review", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Query Parameter Binding](/records/lexicon/query-parameter-binding), [Input Validation](/records/architecture/input-validation), [Secure by Default](/records/architecture/secure-by-default), [Injection-Safe Data Access](/records/lexicon/injection-safe-data-access)", "term": "Depends on" }, { "description": "[String-Concatenated SQL](/records/lexicon/string-concatenated-sql)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-parameterized-queries", "title": "Parameterized Queries" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security / Privacy / Compliance / Governance](/records/architecture-category/security-privacy-compliance-governance)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Mandatory for: sensitive systems", "Scope: service, authentication, security", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that keeps authenticated sessions on the server, with expiry, rotation and revocation, and gives the client only an opaque identifier.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Authentication](/records/architecture/authentication)", "term": "Requires" }, { "description": "[Access Control](/records/architecture/access-control), [Least Privilege](/records/architecture/least-privilege)", "term": "Reinforces" }, { "description": "[Bounded Session Lifetime](/records/lexicon/bounded-session-lifetime), [Revocable Access](/records/lexicon/revocable-access)", "term": "Enables" }, { "description": "[User Convenience](/records/lexicon/user-convenience)", "term": "In tension with" }, { "description": "[Immortal Client-Trusted Session](/records/lexicon/immortal-client-trusted-session)", "term": "Conflicts with" }, { "description": "[Session Management / User Convenience](/records/tension/session-management-user-convenience)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Immortal Client-Trusted Session](/records/lexicon/immortal-client-trusted-session)", "term": "Violated by" }, { "description": "no expiry/rotation/revocation on sessions", "term": "Detected by" }, { "description": "unbounded-session count", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "security review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "res.cookie(\"userId\", user.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const session = await sessions.create(user.id, { ttlMs: 3_600_000, rotateOnAuth: true });\nres.cookie(\"sid\", session.id, { httpOnly: true, secure: true, sameSite: \"strict\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "security review", "term": "Checked by" }, { "description": "Every endpoint, credential, data store, permission and policy inside the trust boundary", "term": "Population" }, { "description": "A verdict stands until the code, the policy, the configuration or the threat model changes", "term": "Freshness" }, { "description": "The security gate, policy engine or secret scan fails the change or rejects the request", "term": "Refusal" }, { "description": "Scans of source and configuration, policy decisions, and security test results", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The policy and the threat model, which code, configuration and requests conform to", "term": "Authoritative side" }, { "description": "[Authentication](/records/architecture/authentication), [Access Control](/records/architecture/access-control), [Least Privilege](/records/architecture/least-privilege), [Bounded Session Lifetime](/records/lexicon/bounded-session-lifetime), [Revocable Access](/records/lexicon/revocable-access)", "term": "Depends on" }, { "description": "[Immortal Client-Trusted Session](/records/lexicon/immortal-client-trusted-session)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-session-management", "title": "Session Management" } ], "title": "Security / Privacy / Compliance / Governance" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_ports_and_adapters_architecture[\"Ports and Adapters Architecture\"]\n n_clean_architecture[\"Clean Architecture\"]\n n_layered_architecture[\"Layered Architecture\"]\n n_component_based_architecture[\"Component-Based Architecture\"]\n n_package_by_feature[\"Package by Feature\"]\n n_microservices[\"Microservices\"]\n n_monolith_architecture[\"Monolith Architecture\"]\n n_pipes_and_filters[\"Pipes and Filters\"]\n n_service_oriented_architecture[\"Service-Oriented Architecture\"]\n n_space_based_architecture[\"Space-Based Architecture\"]\n n_ports_and_adapters_architecture --> n_clean_architecture" } ], "icon": "bi-collection", "id": "architecture-category-codebase-system-architecture-styles", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: application, service, component", "Aliases: Hexagonal Architecture, Ports and Adapters", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of keeping a domain core free of framework and data types, with every external dependency behind a port the application owns and implemented by an adapter outside it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Ports](/records/lexicon/ports), [Adapters](/records/lexicon/adapters), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Domain Core](/records/lexicon/domain-core)", "term": "Requires" }, { "description": "[Replaceability](/records/architecture/replaceability), [Testability](/records/architecture/testability), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Reinforces" }, { "description": "[Infrastructure Independence](/records/lexicon/infrastructure-independence), [External System Isolation](/records/lexicon/external-system-isolation)", "term": "Enables" }, { "description": "[Boilerplate](/records/lexicon/boilerplate), [Initial Complexity](/records/lexicon/initial-complexity)", "term": "In tension with" }, { "description": "[Framework Leakage](/records/architecture/framework-leakage)", "term": "Conflicts with" }, { "description": "[Replaceability](/records/architecture/replaceability), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion)", "term": "Referenced by" }, { "description": "[Ports and Adapters Architecture / Boilerplate](/records/tension/boilerplate-ports-and-adapters-architecture), [Ports and Adapters Architecture / Initial Complexity](/records/tension/initial-complexity-ports-and-adapters-architecture)", "term": "Tensions" }, { "description": "[Clean Architecture](/records/architecture/clean-architecture): Ports and adapters isolates the core behind ports, while clean architecture arranges concentric layers whose dependencies point inward.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Framework Leakage](/records/architecture/framework-leakage)", "term": "Violated by" }, { "description": "inward/outward dependency violations, dependency direction violations", "term": "Detected by" }, { "description": "adapter coverage, boundary purity, core purity score", "term": "Measured by" }, { "description": "[Introduce Port](/records/lexicon/introduce-port), [Extract Adapter](/records/lexicon/extract-adapter), [Move Framework Outward](/records/lexicon/move-framework-outward)", "term": "Refactored by" }, { "description": "layer dependency rules, architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooService {\n save(foo: Foo) { return sql.query(\"insert into foo values (?)\", foo); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface SaveFooPort { save(foo: Foo): Promise; }\nclass FooService {\n constructor(private readonly port: SaveFooPort) {}\n save(foo: Foo) { return this.port.save(foo); }\n}\nclass SqlFooAdapter implements SaveFooPort { save(foo: Foo) { return sqlFooStore.save(foo); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "layer dependency rules, architecture tests", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Ports](/records/lexicon/ports), [Adapters](/records/lexicon/adapters), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Domain Core](/records/lexicon/domain-core), [Replaceability](/records/architecture/replaceability), [Testability](/records/architecture/testability), [Clean Architecture](/records/architecture/clean-architecture), [Infrastructure Independence](/records/lexicon/infrastructure-independence), [External System Isolation](/records/lexicon/external-system-isolation)", "term": "Depends on" }, { "description": "[Framework Leakage](/records/architecture/framework-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-ports-and-adapters-architecture", "title": "Ports and Adapters Architecture" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: application, system", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of concentric layers in which source dependencies point only inward, towards the use cases and entities.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Dependency Rule](/records/lexicon/dependency-rule), [Use Cases](/records/lexicon/use-cases), [Boundaries](/records/lexicon/boundaries)", "term": "Requires" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Framework Independence](/records/lexicon/framework-independence)", "term": "Enables" }, { "description": "[Boilerplate](/records/lexicon/boilerplate)", "term": "In tension with" }, { "description": "[Layer Leakage](/records/lexicon/layer-leakage)", "term": "Conflicts with" }, { "description": "[Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" }, { "description": "[Clean Architecture / Boilerplate](/records/tension/boilerplate-clean-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Layer Leakage](/records/lexicon/layer-leakage)", "term": "Violated by" }, { "description": "dependency rule violations", "term": "Detected by" }, { "description": "inward dependency compliance", "term": "Measured by" }, { "description": "[Move Logic to the Domain](/records/lexicon/move-logic-to-the-domain), [Extract Interface](/records/lexicon/extract-interface), [Extract Adapter](/records/lexicon/extract-adapter)", "term": "Refactored by" }, { "description": "dependency graph rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class FooController {\n async create(request: Request) { return orm.foo.create(await request.json()); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "interface CreateFooGateway { save(foo: Foo): Promise; }\nclass CreateFooInteractor {\n constructor(private readonly gateway: CreateFooGateway) {}\n execute(input: CreateFooInput) { return this.gateway.save(Foo.create(input)); }\n}\nclass FooController { constructor(private readonly useCase: CreateFooInteractor) {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "dependency graph rules", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Dependency Rule](/records/lexicon/dependency-rule), [Use Cases](/records/lexicon/use-cases), [Boundaries](/records/lexicon/boundaries), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Testability](/records/architecture/testability), [Framework Independence](/records/lexicon/framework-independence)", "term": "Depends on" }, { "description": "[Layer Leakage](/records/lexicon/layer-leakage)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-clean-architecture", "title": "Clean Architecture" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, system", "Aliases: N-Tier Architecture", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of stacking presentation, application and persistence layers, each calling only the layer below it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Layer Separation](/records/lexicon/layer-separation)", "term": "Requires" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Reinforces" }, { "description": "[Structured Code Organization](/records/lexicon/structured-code-organization)", "term": "Enables" }, { "description": "[Anemic Layers](/records/lexicon/anemic-layers)", "term": "In tension with" }, { "description": "[Layer Skipping](/records/lexicon/layer-skipping)", "term": "Conflicts with" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Referenced by" }, { "description": "[Layered Architecture / Anemic Layers](/records/tension/anemic-layers-layered-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Layer Skipping](/records/lexicon/layer-skipping)", "term": "Violated by" }, { "description": "forbidden layer imports", "term": "Detected by" }, { "description": "layer violation count", "term": "Measured by" }, { "description": "[Move Behavior to Its Owner](/records/lexicon/move-behavior-to-its-owner), [Introduce Port](/records/lexicon/introduce-port)", "term": "Refactored by" }, { "description": "layer rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function createFoo(request: Request) {\n return sql.query(\"insert into foo values (?)\", JSON.parse(request.body));\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooController { constructor(private readonly service: FooService) {} }\nclass FooService { constructor(private readonly repository: FooRepository) {} }\nclass SqlFooRepository implements FooRepository { save(foo: Foo) { return fooTable.insert(foo); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "layer rules", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Layer Separation](/records/lexicon/layer-separation), [Separation of Concerns](/records/architecture/separation-of-concerns), [Structured Code Organization](/records/lexicon/structured-code-organization)", "term": "Depends on" }, { "description": "[Layer Skipping](/records/lexicon/layer-skipping)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-layered-architecture", "title": "Layered Architecture" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: component, system", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of building a system from components that declare what they export and what they require.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Component Boundaries](/records/lexicon/component-boundaries), [Contracts](/records/lexicon/contracts)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Composability](/records/architecture/composability)", "term": "Reinforces" }, { "description": "[Reuse](/records/lexicon/reuse), [Replaceability](/records/architecture/replaceability)", "term": "Enables" }, { "description": "[Integration Overhead](/records/lexicon/integration-overhead)", "term": "In tension with" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Conflicts with" }, { "description": "[Component-Based Architecture / Integration Overhead](/records/tension/component-based-architecture-integration-overhead)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Exposed Internals](/records/lexicon/exposed-internals)", "term": "Violated by" }, { "description": "boundary import violations", "term": "Detected by" }, { "description": "component cohesion/coupling", "term": "Measured by" }, { "description": "[Extract Module](/records/lexicon/extract-module), [Define Contract](/records/lexicon/define-contract)", "term": "Refactored by" }, { "description": "component ownership rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const app = {\n createFoo,\n createBar,\n renderFoo,\n saveBar,\n publishBaz,\n};", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooComponent = defineComponent({\n name: \"foo\",\n exports: { createFoo, FooView },\n requires: { FooStore, EventBus },\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "component ownership rules", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Component Boundaries](/records/lexicon/component-boundaries), [Contracts](/records/lexicon/contracts), [Modularity](/records/architecture/modularity), [Composability](/records/architecture/composability), [Reuse](/records/lexicon/reuse), [Replaceability](/records/architecture/replaceability)", "term": "Depends on" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-component-based-architecture", "title": "Component-Based Architecture" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: package, module", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that code is grouped by the feature it serves, so one change stays inside one package.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Feature Cohesion](/records/lexicon/feature-cohesion)", "term": "Requires" }, { "description": "[Modularity](/records/architecture/modularity), [Bounded Context](/records/architecture/bounded-context)", "term": "Reinforces" }, { "description": "[Locality of Change](/records/lexicon/locality-of-change)", "term": "Enables" }, { "description": "[Shared Technical Concerns](/records/lexicon/shared-technical-concerns)", "term": "In tension with" }, { "description": "[Package by Technical Layer Only](/records/lexicon/package-by-technical-layer-only)", "term": "Conflicts with" }, { "description": "[Package by Feature / Shared Technical Concerns](/records/tension/package-by-feature-shared-technical-concerns)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Package by Technical Layer Only](/records/lexicon/package-by-technical-layer-only)", "term": "Violated by" }, { "description": "change sets spanning many layer packages", "term": "Detected by" }, { "description": "change locality", "term": "Measured by" }, { "description": "[Repackage by Feature](/records/lexicon/repackage-by-feature), [Extract Module](/records/lexicon/extract-module)", "term": "Refactored by" }, { "description": "package conventions", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "src/controllers/foo.ts\nsrc/controllers/bar.ts\nsrc/services/foo.ts\nsrc/services/bar.ts\nsrc/repositories/foo.ts\nsrc/repositories/bar.ts", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "src/foo/controller.ts\nsrc/foo/service.ts\nsrc/foo/repository.ts\nsrc/bar/controller.ts\nsrc/bar/service.ts\nsrc/bar/repository.ts", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "package conventions", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Feature Cohesion](/records/lexicon/feature-cohesion), [Modularity](/records/architecture/modularity), [Bounded Context](/records/architecture/bounded-context), [Locality of Change](/records/lexicon/locality-of-change)", "term": "Depends on" }, { "description": "[Package by Technical Layer Only](/records/lexicon/package-by-technical-layer-only)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-package-by-feature", "title": "Package by Feature" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: system, service, deployment", "Aliases: Microservice Architecture", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of splitting a system into services that each own their data and deploy independently.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Autonomy](/records/architecture/autonomy), [Independent Deployment](/records/lexicon/independent-deployment)", "term": "Requires" }, { "description": "[Scalability](/records/architecture/scalability), [Bounded Context](/records/architecture/bounded-context)", "term": "Reinforces" }, { "description": "[Decentralized Ownership](/records/lexicon/decentralized-ownership)", "term": "Enables" }, { "description": "[Operational Complexity](/records/lexicon/operational-complexity), [Consistency](/records/architecture/consistency)", "term": "In tension with" }, { "description": "[Distributed Monolith](/records/architecture/distributed-monolith)", "term": "Conflicts with" }, { "description": "[Bounded Context](/records/architecture/bounded-context), [Decentralization](/records/architecture/decentralization), [Autonomy](/records/architecture/autonomy)", "term": "Referenced by" }, { "description": "[Microservices / Operational Complexity](/records/tension/microservices-operational-complexity), [Microservices / Consistency](/records/tension/consistency-microservices)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Database](/records/lexicon/shared-database), [Synchronous Chain Trap](/records/architecture/synchronous-chain-trap)", "term": "Violated by" }, { "description": "deployment coupling, cross-service transactions", "term": "Detected by" }, { "description": "deploy independence, coupling metrics", "term": "Measured by" }, { "description": "[Split Bounded Context](/records/lexicon/split-bounded-context), [Own Data per Service](/records/lexicon/own-data-per-service), [Domain Events](/records/architecture/domain-events)", "term": "Refactored by" }, { "description": "service ownership, API contracts", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class SharedApplication {\n createFoo(foo: Foo) { return sharedDb.insert(\"foo\", foo); }\n createBar(bar: Bar) { return sharedDb.insert(\"bar\", bar); }\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooService {\n constructor(private readonly fooStore: FooStore, private readonly outbox: Outbox) {}\n create(foo: Foo) { return transact(() => [this.fooStore.save(foo), this.outbox.append(fooCreated(foo))]); }\n}\nclass BarService { constructor(private readonly barStore: BarStore) {} }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "service ownership, API contracts", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Autonomy](/records/architecture/autonomy), [Independent Deployment](/records/lexicon/independent-deployment), [Scalability](/records/architecture/scalability), [Bounded Context](/records/architecture/bounded-context), [Decentralized Ownership](/records/lexicon/decentralized-ownership)", "term": "Depends on" }, { "description": "[Distributed Monolith](/records/architecture/distributed-monolith)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-microservices", "title": "Microservices" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, deployment", "Aliases: Monolith", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of deploying a system as one unit, with its modules kept apart by internal boundaries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Unified Deployment Boundary](/records/lexicon/unified-deployment-boundary)", "term": "Requires" }, { "description": "[Operational Simplicity](/records/lexicon/operational-simplicity)", "term": "Reinforces" }, { "description": "[Transactional Simplicity](/records/lexicon/transactional-simplicity)", "term": "Enables" }, { "description": "[Team Autonomy](/records/lexicon/team-autonomy), [Independent Scaling](/records/lexicon/independent-scaling)", "term": "In tension with" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Conflicts with" }, { "description": "[Monolith Architecture / Team Autonomy](/records/tension/monolith-architecture-team-autonomy), [Monolith Architecture / Independent Scaling](/records/tension/independent-scaling-monolith-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Violated by" }, { "description": "cyclic packages, high global coupling", "term": "Detected by" }, { "description": "module boundary health", "term": "Measured by" }, { "description": "[Define Module Boundaries](/records/lexicon/define-module-boundaries)", "term": "Refactored by" }, { "description": "modular monolith rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await http.post(\"foo-service\", foo);\nawait http.post(\"bar-service\", bar);\nawait http.post(\"baz-service\", baz);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class ModularMonolith {\n constructor(readonly foo: FooModule, readonly bar: BarModule, readonly baz: BazModule) {}\n}\nawait app.foo.create(foo);\nawait app.bar.create(bar);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "modular monolith rules", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Unified Deployment Boundary](/records/lexicon/unified-deployment-boundary), [Operational Simplicity](/records/lexicon/operational-simplicity), [Transactional Simplicity](/records/lexicon/transactional-simplicity)", "term": "Depends on" }, { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-monolith-architecture", "title": "Monolith Architecture" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: application, data processing, composition", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of processing data through independent stages that share one input and output interface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Uniform Stage Interface](/records/lexicon/uniform-stage-interface)", "term": "Requires" }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Composability](/records/architecture/composability)", "term": "Reinforces" }, { "description": "[Reorderable Stages](/records/lexicon/reorderable-stages), [Independent Stage Testing](/records/lexicon/independent-stage-testing)", "term": "Enables" }, { "description": "[End-to-End Traceability](/records/lexicon/end-to-end-traceability)", "term": "In tension with" }, { "description": "[Monolithic Transform Function](/records/lexicon/monolithic-transform-function)", "term": "Conflicts with" }, { "description": "[Pipes and Filters / End-to-End Traceability](/records/tension/end-to-end-traceability-pipes-and-filters)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Monolithic Transform Function](/records/lexicon/monolithic-transform-function)", "term": "Violated by" }, { "description": "long sequential transform bodies", "term": "Detected by" }, { "description": "transform-step count per function", "term": "Measured by" }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Refactored by" }, { "description": "[design review](/records/architecture/design-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function processFoo(raw: string) {\n const parsed = parseFoo(raw);\n const cleaned = cleanFoo(parsed);\n return enrichFoo(cleaned);\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const filters: FooFilter[] = [parseFoo, cleanFoo, enrichFoo];\nconst fooPipeline = connect(filters);\nfooPipeline.run(raw);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "design review", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Uniform Stage Interface](/records/lexicon/uniform-stage-interface), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Composability](/records/architecture/composability), [Reorderable Stages](/records/lexicon/reorderable-stages), [Independent Stage Testing](/records/lexicon/independent-stage-testing)", "term": "Depends on" }, { "description": "[Monolithic Transform Function](/records/lexicon/monolithic-transform-function)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pipes-and-filters", "title": "Pipes and Filters" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, service, integration", "Aliases: SOA", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of exposing each business capability as a service governed by a published contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Requires" }, { "description": "[Autonomy](/records/architecture/autonomy), [Low Coupling](/records/architecture/low-coupling)", "term": "Reinforces" }, { "description": "[Contract-Governed Service Reuse](/records/lexicon/contract-governed-service-reuse)", "term": "Enables" }, { "description": "[Operational Overhead](/records/lexicon/operational-overhead)", "term": "In tension with" }, { "description": "[Shared Monolithic Application](/records/lexicon/shared-monolithic-application)", "term": "Conflicts with" }, { "description": "[Service-Oriented Architecture / Operational Overhead](/records/tension/operational-overhead-service-oriented-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared Monolithic Application](/records/lexicon/shared-monolithic-application)", "term": "Violated by" }, { "description": "unrelated operations sharing one class/module", "term": "Detected by" }, { "description": "capability cohesion per module", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "class Application {\n createFoo() {}\n createBar() {}\n createBaz() {}\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooService = registerService(\"FooService\", { create: createFoo }, { contract: FooServiceContract });\nserviceBus.expose(fooService);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Service Contract](/records/architecture/service-contract), [Autonomy](/records/architecture/autonomy), [Low Coupling](/records/architecture/low-coupling), [Contract-Governed Service Reuse](/records/lexicon/contract-governed-service-reuse)", "term": "Depends on" }, { "description": "[Shared Monolithic Application](/records/lexicon/shared-monolithic-application)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-service-oriented-architecture", "title": "Service-Oriented Architecture" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Codebase / System Architecture Styles](/records/architecture-category/codebase-system-architecture-styles)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: application, scalability, distributed state", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of holding working state in a replicated in-memory space, so no central database limits scaling.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Replicated In-Memory State](/records/lexicon/replicated-in-memory-state)", "term": "Requires" }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Elasticity](/records/architecture/elasticity)", "term": "Reinforces" }, { "description": "[Database-Bottleneck Removal](/records/lexicon/database-bottleneck-removal)", "term": "Enables" }, { "description": "[Consistency](/records/architecture/consistency)", "term": "In tension with" }, { "description": "[Central Database Bottleneck](/records/lexicon/central-database-bottleneck)", "term": "Conflicts with" }, { "description": "[Space-Based Architecture / Consistency](/records/tension/consistency-space-based-architecture)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Central Database Bottleneck](/records/lexicon/central-database-bottleneck)", "term": "Violated by" }, { "description": "single datastore as the scaling limit", "term": "Detected by" }, { "description": "central-datastore contention rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "[architecture review](/records/architecture/architecture-review)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await centralDatabase.find(id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const foo = await fooSpace.read(id);\nfooSpace.on(\"write\", replicateToPeers);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "architecture review", "term": "Checked by" }, { "description": "Every import, package and service boundary the style's dependency rules range over", "term": "Population" }, { "description": "A verdict stands until an import, a package boundary or a deployment unit changes", "term": "Freshness" }, { "description": "The layer or dependency rule fails the build on an edge the style forbids", "term": "Refusal" }, { "description": "The import graph and the deployment topology, read from source and configuration", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The style's declared dependency rules, which every import and deployment edge conforms to", "term": "Authoritative side" }, { "description": "[Replicated In-Memory State](/records/lexicon/replicated-in-memory-state), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Elasticity](/records/architecture/elasticity), [Database-Bottleneck Removal](/records/lexicon/database-bottleneck-removal)", "term": "Depends on" }, { "description": "[Central Database Bottleneck](/records/lexicon/central-database-bottleneck)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-space-based-architecture", "title": "Space-Based Architecture" } ], "title": "Codebase / System Architecture Styles" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_stated_invariant[\"Stated Invariant\"]\n n_derived_record_state[\"Derived Record State\"]\n n_declared_subject[\"Declared Subject\"]\n n_write_barrier[\"Write Barrier\"]\n n_operand_free_outcome_surface[\"Operand-Free Outcome Surface\"]\n n_projection_channel[\"Projection Channel\"]\n n_two_direction_index[\"Two-Direction Index\"]\n n_independent_lifetime_axes[\"Independent Lifetime Axes\"]\n n_section_lifetime_divergence[\"Section Lifetime Divergence\"]\n n_write_scope_and_read_population[\"Write Scope and Read Population\"]\n n_read_time_join[\"Read-Time Join\"]\n n_one_sided_liveness[\"One-Sided Liveness\"]\n n_reversible_channel_encoding[\"Reversible Channel Encoding\"]\n n_declare_before_read_order[\"Declare-Before-Read Order\"]\n n_period_decided_disposition[\"Period-Decided Disposition\"]\n n_derived_party_count[\"Derived Party Count\"]\n n_fan_in_ceiling[\"Fan-In Ceiling\"]\n n_state_arity_limit[\"State-Arity Limit\"]\n n_carrier_and_payload_split[\"Carrier and Payload Split\"]\n n_joinable_mandated_field[\"Joinable Mandated Field\"]\n n_single_aggregate[\"Single Aggregate\"]\n n_contradicted_invariant[\"Contradicted Invariant\"]\n n_written_status_marker[\"Written Status Marker\"]\n n_invocation_keyed_report[\"Invocation-Keyed Report\"]\n n_narrowed_aggregate[\"Narrowed Aggregate\"]\n n_cyclic_tiebreak[\"Cyclic Tiebreak\"]\n n_destructive_closure[\"Destructive Closure\"]\n n_hand_kept_index[\"Hand-Kept Index\"]\n n_stated_invariant --x n_contradicted_invariant\n n_derived_record_state --x n_written_status_marker\n n_operand_free_outcome_surface --> n_stated_invariant\n n_operand_free_outcome_surface --x n_contradicted_invariant\n n_two_direction_index --x n_hand_kept_index\n n_independent_lifetime_axes --x n_destructive_closure\n n_section_lifetime_divergence --> n_independent_lifetime_axes\n n_read_time_join --> n_write_scope_and_read_population\n n_period_decided_disposition --x n_cyclic_tiebreak\n n_fan_in_ceiling --> n_derived_party_count\n n_joinable_mandated_field --> n_carrier_and_payload_split\n n_single_aggregate --x n_invocation_keyed_report\n n_single_aggregate --x n_narrowed_aggregate" } ], "icon": "bi-collection", "id": "architecture-category-coordination-surfaces", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: topology, coordination", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that an invariant a topology relies on is written with its property in a form that could be false, the set it ranges over, the parties it binds and the thing that would object if it stopped holding.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Surface](/records/lexicon/coordination-surface)", "term": "Requires" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Conflicts with" }, { "description": "[Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Referenced by" }, { "description": "[INVARIANT](/records/pag/keyword-invariant), [invariant_record](/records/pag/production-invariant-record), [invariant_block](/records/pag/production-invariant-block)", "term": "Expressed in the grammar by" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unobjected Invariant](/records/lexicon/unobjected-invariant), [Unreceived Invariant](/records/lexicon/unreceived-invariant)", "term": "Violated by" }, { "description": "an invariant with no objector, or one that names no set or no bound party", "term": "Detected by" }, { "description": "invariants stated without an objector and not marked unheld", "term": "Measured by" }, { "description": "[Name the Objector](/records/lexicon/name-the-objector), [Mark the Invariant Unheld](/records/lexicon/mark-the-invariant-unheld)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "every surface has one writer → nothing counts writers → a second writer lands and every guarantee resting on the first still reads as sound", "kind": "code", "language": "text", "title": "Before" }, { "code": "property: one writer per record → set: every record on a coordination surface → parties: every writer → objector: a check failing a record whose fence names two writers", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Surface](/records/lexicon/coordination-surface), [Fitness Functions](/records/architecture/fitness-functions), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-stated-invariant", "title": "Stated Invariant" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: record, coordination", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a record's state is a query over the edges it carries, open while its satisfying artifact is unresolved, blocked while a blocker is open and absorbed once the artifact exists, so no party writes a state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Record](/records/lexicon/coordination-record), [Acknowledger](/records/lexicon/acknowledger)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Written Status Marker](/records/architecture/written-status-marker)", "term": "Conflicts with" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth): Derived record state applies one owning source to a record's status, while a single source of truth covers any fact, rule or configuration value.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Written Status Marker](/records/architecture/written-status-marker)", "term": "Violated by" }, { "description": "a record carrying a state that its edges no longer support", "term": "Detected by" }, { "description": "records whose written state differs from the derived one", "term": "Measured by" }, { "description": "[Derive State from Edges](/records/lexicon/derive-state-from-edges)", "term": "Refactored by" }, { "description": "the coordination closure check, which refuses a judgment closure that cites an artifact and an artifact closure that cites none", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a record reads status: done → its artifact was later deleted → the marker still asserts done", "kind": "code", "language": "text", "title": "Before" }, { "code": "the record cites satisfied-by: → the artifact resolves: absorbed → the artifact is gone: open, with no field anyone has to remember to change", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination closure check, which refuses a judgment closure that cites an artifact and an artifact closure that cites none", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Record](/records/lexicon/coordination-record), [Acknowledger](/records/lexicon/acknowledger), [Single Source of Truth](/records/architecture/single-source-of-truth), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Written Status Marker](/records/architecture/written-status-marker)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-derived-record-state", "title": "Derived Record State" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: record, identity", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a record carries an allocated id and a declared subject key as two fields, so a moved surface keeps the id, a renamed subject keeps the key, and two records sharing a key are a finding.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Record](/records/lexicon/coordination-record)", "term": "Requires" }, { "description": "[Stable Identity](/records/lexicon/stable-identity)", "term": "Reinforces" }, { "description": "[Rederivation Detection](/records/lexicon/rederivation-detection)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Stable Identity](/records/lexicon/stable-identity): A declared subject keeps a record's id and its subject as two fields that survive different renames, while stable identity requires only that one identifier last the entity's lifetime.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Location-Derived Identity](/records/lexicon/location-derived-identity)", "term": "Violated by" }, { "description": "a record whose id changes when its surface moves, or two records about one subject", "term": "Detected by" }, { "description": "records sharing a subject key", "term": "Measured by" }, { "description": "[Allocate Identity Once](/records/lexicon/allocate-identity-once), [Declare the Subject Beside the Id](/records/lexicon/declare-the-subject-beside-the-id)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "record id = - → the surface moves → every id changes and every edge citing one dangles", "kind": "code", "language": "text", "title": "Before" }, { "code": "id = -, allocated once → subject = → a second record declaring the same subject is reported", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Record](/records/lexicon/coordination-record), [Stable Identity](/records/lexicon/stable-identity), [Rederivation Detection](/records/lexicon/rederivation-detection)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-declared-subject", "title": "Declared Subject" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: surface, concurrency", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a planned exclusive write to a shared surface proceed only once every peer is observed parked, beside a compare-and-swap that covers every other write.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Surface](/records/lexicon/coordination-surface)", "term": "Requires" }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Reinforces" }, { "description": "[Single-Writer Coordination](/records/lexicon/single-writer-coordination)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Conflicts with" }, { "description": "[refusal_line](/records/pag/production-refusal-line)", "term": "Expressed in the grammar by" } ], "kind": "glossary" }, { "entries": [ { "description": "[Whole-Surface Rewrite](/records/lexicon/whole-surface-rewrite)", "term": "Violated by" }, { "description": "content a peer wrote missing after an exclusive write that reported success", "term": "Detected by" }, { "description": "exclusive writes taken without every peer observed parked", "term": "Measured by" }, { "description": "[Hold the Barrier for Planned Writes](/records/lexicon/hold-the-barrier-for-planned-writes), [Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a tool rewrites the board whole → a peer's record written a moment earlier is gone → every check passes", "kind": "code", "language": "text", "title": "Before" }, { "code": "planned rewrite → wait until every peer is parked → write → any other write: re-read, compare its own span, refuse with the diff on an overlap", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Surface](/records/lexicon/coordination-surface), [Optimistic Locking](/records/architecture/optimistic-locking), [Single-Writer Coordination](/records/lexicon/single-writer-coordination)", "term": "Depends on" }, { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-write-barrier", "title": "Write Barrier" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: surface, authorship", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a surface carrying one jointly authored product declares that one writer per record has no operand there, and settles a collision by announcement and by each author cutting its own duplicate.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Outcome Surface](/records/lexicon/outcome-surface)", "term": "Requires" }, { "description": "[Stated Invariant](/records/architecture/stated-invariant)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Conflicts with" }, { "description": "[Stated Invariant](/records/architecture/stated-invariant): An operand-free outcome surface declares where one invariant cannot apply, while a stated invariant is the form every invariant is written in.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Assumed Single Writer](/records/lexicon/assumed-single-writer), [Fenced Joint Surface](/records/lexicon/fenced-joint-surface)", "term": "Violated by" }, { "description": "an outcome surface with no declaration that the invariant has no operand there", "term": "Detected by" }, { "description": "outcome surfaces missing the declaration", "term": "Measured by" }, { "description": "[Declare the Missing Operand](/records/lexicon/declare-the-missing-operand), [Settle Collisions by Announcement](/records/lexicon/settle-collisions-by-announcement)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a class statement written by several parties → the one-writer invariant is assumed to hold → nothing objects when two parties write the same clause", "kind": "code", "language": "text", "title": "Before" }, { "code": "the surface declares: one writer per record has no operand here → a collision is announced → each author cuts its own duplicate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Outcome Surface](/records/lexicon/outcome-surface), [Stated Invariant](/records/architecture/stated-invariant), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-operand-free-outcome-surface", "title": "Operand-Free Outcome Surface" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: context, reader", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that the projection a host injects into every bounded reader is refreshed in the same change as the fact it carries, in a shape a check reads.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Host Projection](/records/lexicon/host-projection), [Bounded Reader](/records/lexicon/bounded-reader)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Deferred Projection](/records/lexicon/deferred-projection), [Overgrown Projection](/records/lexicon/overgrown-projection)", "term": "Violated by" }, { "description": "a projection line that disagrees with the surface it summarizes", "term": "Detected by" }, { "description": "changes that moved a projected fact without the projection", "term": "Measured by" }, { "description": "[Refresh the Projection in the Same Change](/records/lexicon/refresh-the-projection-in-the-same-change), [Check the Projection's Shape](/records/lexicon/check-the-projection-s-shape)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a seat goes inactive on the board → the injected line still lists it → every spawned reader plans around a party that is gone", "kind": "code", "language": "text", "title": "Before" }, { "code": "the board write and the projection write land in one change → a check reads the projection's declared shape", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Host Projection](/records/lexicon/host-projection), [Bounded Reader](/records/lexicon/bounded-reader), [Single Source of Truth](/records/architecture/single-source-of-truth), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-projection-channel", "title": "Projection Channel" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: index, directory", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that generates an index from the directory on every run and checks it both ways, reporting an entry with no file and a file with no entry, with every scan independent of depth.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Surface](/records/lexicon/coordination-surface)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Hand-Kept Index](/records/architecture/hand-kept-index)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hand-Kept Index](/records/architecture/hand-kept-index), [One-Way Index Check](/records/lexicon/one-way-index-check)", "term": "Violated by" }, { "description": "an index entry that resolves to no file, or a file no entry names", "term": "Detected by" }, { "description": "index entries and files missing their counterpart", "term": "Measured by" }, { "description": "[Generate the Index from the Directory](/records/lexicon/generate-the-index-from-the-directory), [Check Both Directions](/records/lexicon/check-both-directions)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "the agent index is edited by hand → a seat is added without an entry → the scan covers fewer seats than it claims", "kind": "code", "language": "text", "title": "Before" }, { "code": "the index is generated from the directory → an entry with no file fails → a file with no entry fails", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Surface](/records/lexicon/coordination-surface), [Single Source of Truth](/records/architecture/single-source-of-truth), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Hand-Kept Index](/records/architecture/hand-kept-index)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-two-direction-index", "title": "Two-Direction Index" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: surface, lifetime", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a surface's lifetime is declared on three independent axes, retention, mutability and removal authority, each taking a value from a closed set, so no single word stands for all three.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Retention](/records/lexicon/retention), [Mutability](/records/lexicon/mutability), [Removal Authority](/records/lexicon/removal-authority)", "term": "Requires" }, { "description": "[Immutability](/records/architecture/immutability)", "term": "Reinforces" }, { "description": "[Governed Removal](/records/lexicon/governed-removal)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Destructive Closure](/records/architecture/destructive-closure)", "term": "Conflicts with" }, { "description": "[Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Referenced by" }, { "description": "[Convergence Walk](/records/algorithms/convergence-walk), [Lifetime Resolution](/records/algorithms/lifetime-resolution)", "term": "Contracts" }, { "description": "[Immutability](/records/architecture/immutability): Independent lifetime axes declare mutability as one of three questions about a surface, while immutability is the single rule that a value never changes after it is created.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single-Word Lifetime](/records/lexicon/single-word-lifetime)", "term": "Violated by" }, { "description": "a surface whose lifetime names retention alone", "term": "Detected by" }, { "description": "surfaces missing a value on any axis", "term": "Measured by" }, { "description": "[Declare All Three Lifetime Axes](/records/lexicon/declare-all-three-lifetime-axes)", "term": "Refactored by" }, { "description": "the coordination declaration check, which reports a mechanism named for a lifetime axis that never reads that axis", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "lifetime: deleted on close → a sweep implements it faithfully → the argument behind a ruling is destroyed", "kind": "code", "language": "text", "title": "Before" }, { "code": "retention: kept → mutability: frozen → removal authority: nobody → closing moves the surface to the archive", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination declaration check, which reports a mechanism named for a lifetime axis that never reads that axis", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Retention](/records/lexicon/retention), [Mutability](/records/lexicon/mutability), [Removal Authority](/records/lexicon/removal-authority), [Immutability](/records/architecture/immutability), [Governed Removal](/records/lexicon/governed-removal)", "term": "Depends on" }, { "description": "[Destructive Closure](/records/architecture/destructive-closure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-independent-lifetime-axes", "title": "Independent Lifetime Axes" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: surface, section", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a file states a default lifetime and each section declares only the axes on which it differs, since the narrower unit is the more constrained one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Retention](/records/lexicon/retention), [Mutability](/records/lexicon/mutability)", "term": "Requires" }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Reinforces" }, { "description": "[Governed Removal](/records/lexicon/governed-removal)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[File-Wide Lifetime](/records/lexicon/file-wide-lifetime)", "term": "Violated by" }, { "description": "an operation permitted by the file's lifetime acting on a section whose own lifetime forbids it", "term": "Detected by" }, { "description": "divergent sections carrying no declaration", "term": "Measured by" }, { "description": "[Declare the File Default](/records/lexicon/declare-the-file-default), [Declare Each Divergent Section](/records/lexicon/declare-each-divergent-section)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a document declares owner-rewritable → its contract block is rewritten by a sweep that the file's word allowed", "kind": "code", "language": "text", "title": "Before" }, { "code": "file default: owner-rewritable → contract block: mutability frozen → the sweep skips the block", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Retention](/records/lexicon/retention), [Mutability](/records/lexicon/mutability), [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Governed Removal](/records/lexicon/governed-removal)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-section-lifetime-divergence", "title": "Section Lifetime Divergence" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: run, invocation", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a run declares the paths it writes and publishes the set it read as two declarations, because collision is decided by the first and a published result's validity by the second.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Write Scope](/records/lexicon/write-scope), [Read Population](/records/lexicon/read-population)", "term": "Requires" }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Shared Invocation](/records/lexicon/shared-invocation)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Read-Time Join](/records/architecture/read-time-join)", "term": "Referenced by" }, { "description": "[population_clause](/records/pag/production-population-clause)", "term": "Expressed in the grammar by" }, { "description": "[Determinism](/records/architecture/determinism): Write scope and read population separate what a run touches from what it read, while determinism requires that the same inputs produce the same result.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Conflated Scope](/records/lexicon/conflated-scope)", "term": "Violated by" }, { "description": "a run that reads more than it writes and publishes only its write scope", "term": "Detected by" }, { "description": "runs publishing no read population", "term": "Measured by" }, { "description": "[Declare the Write Scope](/records/lexicon/declare-the-write-scope), [Publish the Read Population](/records/lexicon/publish-the-read-population)", "term": "Refactored by" }, { "description": "the coordination writer check, which fails a writer a run reaches outside the sanctioned set", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a run declares scope: → it also reads a sibling tree → a later caller reuses its result for the sibling and gets a verdict nobody measured", "kind": "code", "language": "text", "title": "Before" }, { "code": "write scope: → read population: + → the collision test reads the first, the coverage test reads the second", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination writer check, which fails a writer a run reaches outside the sanctioned set", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Write Scope](/records/lexicon/write-scope), [Read Population](/records/lexicon/read-population), [Determinism](/records/architecture/determinism), [Shared Invocation](/records/lexicon/shared-invocation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-write-scope-and-read-population", "title": "Write Scope and Read Population" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: run, invocation", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets a caller whose question a live declared scope already covers read that run's published result and its standing, writing nothing, so it cannot deadlock, be orphaned or need cleanup.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Joiner](/records/lexicon/joiner), [Read Population](/records/lexicon/read-population)", "term": "Requires" }, { "description": "[Write Scope and Read Population](/records/architecture/write-scope-and-read-population)", "term": "Reinforces" }, { "description": "[Shared Invocation](/records/lexicon/shared-invocation)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Invocation Join](/records/algorithms/invocation-join)", "term": "Contracts" }, { "description": "[Joiner](/records/lexicon/joiner): A read-time join is the mechanism that serves a covered question from a published result, while a joiner is the caller that uses it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Attached Second Caller](/records/lexicon/attached-second-caller), [Duplicate Covered Run](/records/lexicon/duplicate-covered-run)", "term": "Violated by" }, { "description": "two runs over one covered question, or a caller waiting on another run's handle", "term": "Detected by" }, { "description": "duplicate runs a live scope covered", "term": "Measured by" }, { "description": "[Test Coverage First](/records/lexicon/test-coverage-first), [Join by Reading the Published Result](/records/lexicon/join-by-reading-the-published-result)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a second caller starts the same measurement → both write the same report → the second waits on the first's lock", "kind": "code", "language": "text", "title": "Before" }, { "code": "caller → does a live scope cover the question? yes: read the published result and its standing, write nothing → no: start, and only then enter the collision comparison", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Joiner](/records/lexicon/joiner), [Read Population](/records/lexicon/read-population), [Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Shared Invocation](/records/lexicon/shared-invocation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-read-time-join", "title": "Read-Time Join" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: process, liveness", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a process's absence proves it is dead while its presence proves nothing, so liveness is derived once, from the witness first and from a generous window only where the witness cannot decide.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Liveness Witness](/records/lexicon/liveness-witness)", "term": "Requires" }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Shared Invocation](/records/lexicon/shared-invocation)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Determinism](/records/architecture/determinism): One-sided liveness decides what a process's presence can prove, while determinism requires that the same inputs produce the same result.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Presence as Liveness](/records/lexicon/presence-as-liveness), [Per-Consumer Liveness](/records/lexicon/per-consumer-liveness)", "term": "Violated by" }, { "description": "two consumers of one liveness question reaching different answers", "term": "Detected by" }, { "description": "liveness derivations outside the single one", "term": "Measured by" }, { "description": "[Derive Liveness Once](/records/lexicon/derive-liveness-once), [Witness First](/records/lexicon/witness-first), [Window Second](/records/lexicon/window-second)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a process id is present → the claim is kept → the id was reused by an unrelated process and the claim never expires", "kind": "code", "language": "text", "title": "Before" }, { "code": "id absent: dead → id present: undecided → fall to the window, set long, because too short loses a write and too long costs one re-run", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Liveness Witness](/records/lexicon/liveness-witness), [Determinism](/records/architecture/determinism), [Shared Invocation](/records/lexicon/shared-invocation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-one-sided-liveness", "title": "One-Sided Liveness" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: channel, naming", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a channel name is a total and invertible encoding of the scope it belongs to, with an alphabet that excludes the separator, so a retention check can read the scope back out of the name.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Write Scope](/records/lexicon/write-scope)", "term": "Requires" }, { "description": "[Stable Identity](/records/lexicon/stable-identity)", "term": "Reinforces" }, { "description": "[Governed Removal](/records/lexicon/governed-removal)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Stable Identity](/records/lexicon/stable-identity): A reversible channel encoding lets the owning scope be read back out of a name, while stable identity requires only that the name not change.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Digest-Named Channel](/records/lexicon/digest-named-channel)", "term": "Violated by" }, { "description": "a channel whose name decodes to no scope", "term": "Detected by" }, { "description": "channels no remover can attribute to a scope", "term": "Measured by" }, { "description": "[Encode the Scope Reversibly](/records/lexicon/encode-the-scope-reversibly), [Declare the Remover](/records/lexicon/declare-the-remover)", "term": "Refactored by" }, { "description": "the coordination channel check, which reports a channel whose decoded scope resolves to nothing", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "channel = digest() → channels never collide → no check can tell which channel is stale", "kind": "code", "language": "text", "title": "Before" }, { "code": "channel = encode(), invertible → decode(channel) resolves to nothing → the declared remover deletes it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination channel check, which reports a channel whose decoded scope resolves to nothing", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Write Scope](/records/lexicon/write-scope), [Stable Identity](/records/lexicon/stable-identity), [Governed Removal](/records/lexicon/governed-removal)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-reversible-channel-encoding", "title": "Reversible Channel Encoding" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: run, concurrency", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that orders two simultaneous starters without a lock by writing each entry before reading the set, with the start stamp and then the party identity breaking a tie.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Write Scope](/records/lexicon/write-scope)", "term": "Requires" }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Shared Invocation](/records/lexicon/shared-invocation)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Read Before Declare](/records/lexicon/read-before-declare)", "term": "Violated by" }, { "description": "two runs over one scope that both proceeded", "term": "Detected by" }, { "description": "simultaneous starters that both proceeded", "term": "Measured by" }, { "description": "[Write the Entry Before Reading the Set](/records/lexicon/write-the-entry-before-reading-the-set)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "starter A reads: nobody → starter B reads: nobody → both write → both proceed", "kind": "code", "language": "text", "title": "Before" }, { "code": "A writes its entry → B writes its entry → each reads both → the earlier stamp proceeds, the other exits without writing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Write Scope](/records/lexicon/write-scope), [Determinism](/records/architecture/determinism), [Shared Invocation](/records/lexicon/shared-invocation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-declare-before-read-order", "title": "Declare-Before-Read Order" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: duplicate, derivation", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a duplicate is first counted by its distinguished copies and then read by the period of each derivation edge, so a periodic copy owes a comparator and a one-shot copy is a record whose source is repaired instead.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Distinguished Copy](/records/lexicon/distinguished-copy), [Derivation Period](/records/lexicon/derivation-period)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Cyclic Tiebreak](/records/architecture/cyclic-tiebreak)", "term": "Conflicts with" }, { "description": "[Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk)", "term": "Contracts" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth): Period-decided disposition decides what to do with the copies a fact already has, while a single source of truth is the state it restores.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blanket Collapse](/records/lexicon/blanket-collapse)", "term": "Violated by" }, { "description": "a collapse that removed a copy written once against an earlier state of its source", "term": "Detected by" }, { "description": "copies collapsed across one-shot edges", "term": "Measured by" }, { "description": "[Count Distinguished Copies](/records/lexicon/count-distinguished-copies), [Read Each Period](/records/lexicon/read-each-period), [Repair the Source](/records/lexicon/repair-the-source)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a rule stated in code and in several documents → every document copy is rewritten to match → the record of what each surface said when it was written is gone", "kind": "code", "language": "text", "title": "Before" }, { "code": "one distinguished copy: a direction → every other edge one-shot: diagnose the copies, repair the source → a copy no party reaches: add it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Distinguished Copy](/records/lexicon/distinguished-copy), [Derivation Period](/records/lexicon/derivation-period), [Single Source of Truth](/records/architecture/single-source-of-truth), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Cyclic Tiebreak](/records/architecture/cyclic-tiebreak)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-period-decided-disposition", "title": "Period-Decided Disposition" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: allocation, coordination", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that the number of parties a body of work implies is derived from how the work is partitioned into concerns, so two parties holding one partition reach one count.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concern Partition](/records/lexicon/concern-partition)", "term": "Requires" }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Referenced by" }, { "description": "[Determinism](/records/architecture/determinism): A derived party count ties allocation to a partition of the work, while determinism requires that the same inputs produce the same result.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Preferred Party Count](/records/lexicon/preferred-party-count)", "term": "Violated by" }, { "description": "a count that moved while no partition moved", "term": "Detected by" }, { "description": "counts proposed with no partition behind them", "term": "Measured by" }, { "description": "[Derive the Partition](/records/lexicon/derive-the-partition), [Count the Partition's Concerns](/records/lexicon/count-the-partition-s-concerns)", "term": "Refactored by" }, { "description": "none: no mechanism derives the partition, so the count rests on review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "the work gets a fixed number of parties → surfaces are split to give each one something → contradictions pile up on the shared ones", "kind": "code", "language": "text", "title": "Before" }, { "code": "coupling relation → connected components → concerns → floor: concerns that must contradict each other → ceiling: the worst fan-in", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "none: no mechanism derives the partition, so the count rests on review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Concern Partition](/records/lexicon/concern-partition), [Determinism](/records/architecture/determinism), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-derived-party-count", "title": "Derived Party Count" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: allocation, surface", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that the useful number of parties is bounded by the fan-in of the most contended surface, where claims resting on it go stale faster than they help.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Fan-In](/records/lexicon/fan-in)", "term": "Requires" }, { "description": "[Derived Party Count](/records/architecture/derived-party-count)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Crowded Surface](/records/lexicon/crowded-surface)", "term": "Violated by" }, { "description": "a surface whose claims are answered more often than they are used", "term": "Detected by" }, { "description": "stale claims published per surface", "term": "Measured by" }, { "description": "[Mark Claims with Their Read Moment](/records/lexicon/mark-claims-with-their-read-moment), [Partition the Surface](/records/lexicon/partition-the-surface)", "term": "Refactored by" }, { "description": "none: no mechanism counts fan-in, so the bound rests on review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "more parties join → each composes claims about one shared surface → every stale claim is read and answered by every other party", "kind": "code", "language": "text", "title": "Before" }, { "code": "fan-in measured from recorded authorship and citations → the surface above the ceiling is split or its claims arrive marked stale", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "none: no mechanism counts fan-in, so the bound rests on review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Fan-In](/records/lexicon/fan-in), [Derived Party Count](/records/architecture/derived-party-count), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-fan-in-ceiling", "title": "Fan-In Ceiling" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: check, state", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a property relating two states of content, such as growing but never shrinking, is enforced only by a mechanism holding both readings, in the layer that already spans runs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Coordination Surface](/records/lexicon/coordination-surface)", "term": "Requires" }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Single-State Change Check](/records/lexicon/single-state-change-check), [Remembering Checker](/records/lexicon/remembering-checker)", "term": "Violated by" }, { "description": "content removed from a required section while every single-state check passes", "term": "Detected by" }, { "description": "change rules held only by single-state checks", "term": "Measured by" }, { "description": "[Retain the Prior State in the Spanning Layer](/records/lexicon/retain-the-prior-state-in-the-spanning-layer), [Compare the Two Readings](/records/lexicon/compare-the-two-readings)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a check requires the section → it passes from empty to full and from full to empty alike", "kind": "code", "language": "text", "title": "Before" }, { "code": "the spanning layer records the section's extent per run → the next run compares → shortened: refuse → the sets differ: not comparable, refuse rather than compute", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Coordination Surface](/records/lexicon/coordination-surface), [Fitness Functions](/records/architecture/fitness-functions), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-state-arity-limit", "title": "State-Arity Limit" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: surface, field", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a surface read through a tool types the fields a mechanism joins on and leaves the fields only a reader consumes as prose, deciding the line per field.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Carrier Field](/records/lexicon/carrier-field), [Payload Field](/records/lexicon/payload-field)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Referenced by" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary): The carrier and payload split decides which fields are typed at all, while a closed vocabulary governs the words a typed name slot may take.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Prose-Parsing Mechanism](/records/lexicon/prose-parsing-mechanism), [Restating Payload](/records/lexicon/restating-payload)", "term": "Violated by" }, { "description": "a mechanism parsing a prose field, or a carrier and a payload that answer one question differently", "term": "Detected by" }, { "description": "fields no declaration assigns to either side", "term": "Measured by" }, { "description": "[Type the Carrier](/records/lexicon/type-the-carrier), [Leave the Payload Prose](/records/lexicon/leave-the-payload-prose), [Remove the Restating Payload](/records/lexicon/remove-the-restating-payload)", "term": "Refactored by" }, { "description": "none: whether a value is resolvable is a judgment at authoring, so the split rests on review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a status sentence is parsed for the word done → a reader edits the sentence → the parse misreads it", "kind": "code", "language": "text", "title": "Before" }, { "code": "state: as the carrier → reason: as the payload → the mechanism reads the key and never the sentence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "none: whether a value is resolvable is a judgment at authoring, so the split rests on review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Carrier Field](/records/lexicon/carrier-field), [Payload Field](/records/lexicon/payload-field), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-carrier-and-payload-split", "title": "Carrier and Payload Split" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: field, schema", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a mandated field takes a value from a closed set or an identifier, or declares that it is written for readers, so a governed surface never looks measured on a property nothing can read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Carrier Field](/records/lexicon/carrier-field)", "term": "Requires" }, { "description": "[Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unread Prose Mandate](/records/lexicon/unread-prose-mandate)", "term": "Violated by" }, { "description": "a mandated prose field that no declaration marks as written for readers", "term": "Detected by" }, { "description": "mandated fields in neither a resolvable form nor declared for readers", "term": "Measured by" }, { "description": "[Draw the Value from a Closed Set](/records/lexicon/draw-the-value-from-a-closed-set), [Declare the Field for Readers](/records/lexicon/declare-the-field-for-readers)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "every record must carry a lifetime paragraph → each author writes one → nothing can join on it", "kind": "code", "language": "text", "title": "Before" }, { "code": "lifetime: retention , mutability , removal authority → a check joins on the three values", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Carrier Field](/records/lexicon/carrier-field), [Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-joinable-mandated-field", "title": "Joinable Mandated Field" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: measurement, report", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a shared measurement keeps one aggregate, overwritten by each run that can honestly replace it, while a run that cannot streams its verdict instead of writing a second report.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Read Population](/records/lexicon/read-population)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Invocation-Keyed Report](/records/architecture/invocation-keyed-report), [Narrowed Aggregate](/records/architecture/narrowed-aggregate)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Invocation-Keyed Report](/records/architecture/invocation-keyed-report), [Narrowed Aggregate](/records/architecture/narrowed-aggregate)", "term": "Violated by" }, { "description": "a second report describing the aggregate's subject", "term": "Detected by" }, { "description": "reports beside the aggregate", "term": "Measured by" }, { "description": "[Write the Aggregate Only from a Full Run](/records/lexicon/write-the-aggregate-only-from-a-full-run), [Stream Narrowed Verdicts](/records/lexicon/stream-narrowed-verdicts)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a narrowed run writes report..json → the directory fills with reports each true of one moment → none of them is the state", "kind": "code", "language": "text", "title": "Before" }, { "code": "a full run overwrites the aggregate → a narrowed run prints its verdict and writes nothing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "[Read Population](/records/lexicon/read-population), [Single Source of Truth](/records/architecture/single-source-of-truth), [Traceable Guarantee](/records/lexicon/traceable-guarantee)", "term": "Depends on" }, { "description": "[Invocation-Keyed Report](/records/architecture/invocation-keyed-report), [Narrowed Aggregate](/records/architecture/narrowed-aggregate)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-single-aggregate", "title": "Single Aggregate" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: topology", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one surface states the opposite of an invariant another relies on, so every mechanism faithfully implementing either statement stays green while the invariant is violated.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Stated Invariant](/records/architecture/stated-invariant), [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "restating an invariant in a second surface and changing only one of the copies", "term": "Formed by" }, { "description": "two statements of one invariant that no single query ranges over", "term": "Detected by" }, { "description": "invariants whose copies disagree", "term": "Measured by" }, { "description": "[Treat the Statements as One Unit](/records/lexicon/treat-the-statements-as-one-unit), [Re-Derive Every Copy on Change](/records/lexicon/re-derive-every-copy-on-change)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "the model states one writer per record → a template states one writer per file → a tool built from the template rewrites whole files and every check passes", "kind": "code", "language": "text", "title": "Before" }, { "code": "every copy of the invariant is listed → a change re-derives the set → the most delivered copy is updated first", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-contradicted-invariant", "title": "Contradicted Invariant" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: record", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a party writes a record's state as a marker instead of deriving it from the record's edges, so the marker goes stale and asserts a state that no longer holds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Derived Record State](/records/architecture/derived-record-state)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "adding a status field that parties are trusted to keep current", "term": "Formed by" }, { "description": "a status field whose value the record's edges contradict", "term": "Detected by" }, { "description": "records carrying a written state", "term": "Measured by" }, { "description": "[Derive State from Edges](/records/lexicon/derive-state-from-edges)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "status: absorbed is written and left in place → the record rests there as a marker", "kind": "code", "language": "text", "title": "Before" }, { "code": "absorbed is a transition → extract to the accumulator → delete in the same change", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Written Status Marker](/records/architecture/written-status-marker)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-written-status-marker", "title": "Written Status Marker" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: report", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a run writes its result under a name derived from how it was invoked, beside the shared aggregate, so documents accumulate that each describe a moment and none the state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Single Aggregate](/records/architecture/single-aggregate)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "keying a report's filename on the scope, the caller or the flags of a run", "term": "Formed by" }, { "description": "a report whose name carries a scope or caller segment", "term": "Detected by" }, { "description": "keyed reports beside the aggregate", "term": "Measured by" }, { "description": "[Stream Narrowed Verdicts](/records/lexicon/stream-narrowed-verdicts), [Keep One Aggregate](/records/lexicon/keep-one-aggregate)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "report..json, report..json → nobody prunes them → a reader cannot tell which is current", "kind": "code", "language": "text", "title": "Before" }, { "code": "one aggregate report → narrowed runs print their verdict", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Invocation-Keyed Report](/records/architecture/invocation-keyed-report)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-invocation-keyed-report", "title": "Invocation-Keyed Report" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: report", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a run over a narrowed scope overwrites the whole-scope aggregate, so the aggregate reports a smaller population as though it were the whole.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Single Aggregate](/records/architecture/single-aggregate)", "term": "Referenced by" }, { "description": "[Invocation-Keyed Report](/records/architecture/invocation-keyed-report): A narrowed aggregate overwrites the one aggregate with a partial result, while an invocation-keyed report writes a second document beside it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "writing the aggregate from a run that measured part of its population", "term": "Formed by" }, { "description": "an aggregate whose recorded population is smaller than the declared one", "term": "Detected by" }, { "description": "aggregate writes from narrowed runs", "term": "Measured by" }, { "description": "[Write the Aggregate Only from a Full Run](/records/lexicon/write-the-aggregate-only-from-a-full-run)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a run over one member writes the aggregate → the aggregate now reads clean for the whole tree", "kind": "code", "language": "text", "title": "Before" }, { "code": "the narrowed run streams its verdict → the aggregate keeps the last full run's result", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Narrowed Aggregate](/records/architecture/narrowed-aggregate)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-narrowed-aggregate", "title": "Narrowed Aggregate" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: duplicate", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a tiebreak picks a source among copies none of which is distinguished, turning a correct refusal into a direction no copy supports.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "breaking a tie by recency, path order or authorship when no copy derives from another and none is resolved", "term": "Formed by" }, { "description": "a collapse direction chosen over a set with no distinguished copy", "term": "Detected by" }, { "description": "collapses directed by a tiebreak", "term": "Measured by" }, { "description": "[Refuse and Name the Cycle](/records/lexicon/refuse-and-name-the-cycle)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "no copy is the source → the newest file wins → every other copy is rewritten toward a value nobody decided", "kind": "code", "language": "text", "title": "Before" }, { "code": "no distinguished copy → refuse as a cycle → the decision stays with the party who holds the information", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Cyclic Tiebreak](/records/architecture/cyclic-tiebreak)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-cyclic-tiebreak", "title": "Cyclic Tiebreak" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: venue", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which closing a converged venue deletes it instead of moving it to the archive, keeping the outcome and destroying the argument it came from.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "implementing a lifetime stated as deleted by removing the venue from the repository", "term": "Formed by" }, { "description": "a closed venue that exists in neither the active surface nor the archive", "term": "Detected by" }, { "description": "venues closed by deletion", "term": "Measured by" }, { "description": "[Archive the Absorbed Venue](/records/lexicon/archive-the-absorbed-venue)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "the venue converges → it is deleted → a later reader holds the ruling and cannot tell it from a preference", "kind": "code", "language": "text", "title": "Before" }, { "code": "the venue converges → its outcome is absorbed → the venue moves to the archive with every position intact", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Destructive Closure](/records/architecture/destructive-closure)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-destructive-closure", "title": "Destructive Closure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/architecture-category/coordination-surfaces)", "Severity: [discouraged](/records/vocabulary/severity-discouraged)", "Scope: index", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an index is written by hand beside what it indexes, so it drifts silently because nothing compares the two.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "none", "term": "Requires" }, { "description": "none", "term": "Reinforces" }, { "description": "none", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Two-Direction Index](/records/architecture/two-direction-index)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "adding and removing index entries by hand", "term": "Formed by" }, { "description": "an index entry with no file, or a file with no entry", "term": "Detected by" }, { "description": "entries and files missing their counterpart", "term": "Measured by" }, { "description": "[Generate the Index from the Directory](/records/lexicon/generate-the-index-from-the-directory)", "term": "Refactored by" }, { "description": "coordination review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a seat file is added → the index is not edited → the scan resolves fewer seats than it reports", "kind": "code", "language": "text", "title": "Before" }, { "code": "the index is regenerated from the directory on every run", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "coordination review", "term": "Checked by" }, { "description": "Every coordination surface, record, run declaration and shared measurement a governed tree carries", "term": "Population" }, { "description": "A verdict stands until a surface's schema, a record's writer or subject, or a run's declared scope changes", "term": "Freshness" }, { "description": "The coordination rules fail a surface whose records name no writer or subject, a run with no declared write scope, and an index that disagrees with the directory it indexes", "term": "Refusal" }, { "description": "Each surface's records compared against its declared schema, and each run's writes compared against its declared scope", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The declared schema and lifetime of each surface, which every record and every mechanism acting on it conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "[Hand-Kept Index](/records/architecture/hand-kept-index)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-hand-kept-index", "title": "Hand-Kept Index" } ], "title": "Coordination Surfaces" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_closed_vocabulary[\"Closed Vocabulary\"]\n n_positional_slot_resolution[\"Positional Slot Resolution\"]\n n_concern_folder_correspondence[\"Concern-Folder Correspondence\"]\n n_glob_resolvable_tree[\"Glob-Resolvable Tree\"]\n n_declared_jurisdiction[\"Declared Jurisdiction\"]\n n_bounded_nesting_depth[\"Bounded Nesting Depth\"]\n n_sideways_overflow[\"Sideways Overflow\"]\n n_one_concern_per_file[\"One Concern Per File\"]\n n_narrowest_concern[\"Narrowest Concern\"]\n n_layer_spine_precedence[\"Layer Spine Precedence\"]\n n_agnostic_first_vocabulary[\"Agnostic-First Vocabulary\"]\n n_guided_vocabulary_refusal[\"Guided Vocabulary Refusal\"]\n n_derived_naming_registry[\"Derived Naming Registry\"]\n n_set_relative_member_name[\"Set-Relative Member Name\"]\n n_manual_identity_migration[\"Manual Identity Migration\"]\n n_collision_consolidation[\"Collision Consolidation\"]\n n_mirrored_test_placement[\"Mirrored Test Placement\"]\n n_sanctioned_generic_subject[\"Sanctioned Generic Subject\"]\n n_conformance_at_creation[\"Conformance at Creation\"]\n n_registry_held_order[\"Registry-Held Order\"]\n n_externally_resolved_slot[\"Externally Resolved Slot\"]\n n_case_dialect[\"Case Dialect\"]\n n_root_spine_files[\"Root Spine Files\"]\n n_closed_vocabulary --> n_concern_folder_correspondence\n n_positional_slot_resolution --> n_closed_vocabulary\n n_positional_slot_resolution --> n_concern_folder_correspondence\n n_concern_folder_correspondence --> n_glob_resolvable_tree\n n_glob_resolvable_tree --> n_concern_folder_correspondence\n n_declared_jurisdiction --> n_bounded_nesting_depth\n n_declared_jurisdiction --> n_glob_resolvable_tree\n n_bounded_nesting_depth --> n_sideways_overflow\n n_sideways_overflow --> n_bounded_nesting_depth\n n_one_concern_per_file --> n_narrowest_concern\n n_narrowest_concern --> n_layer_spine_precedence\n n_layer_spine_precedence --> n_narrowest_concern\n n_agnostic_first_vocabulary --> n_closed_vocabulary\n n_guided_vocabulary_refusal --> n_closed_vocabulary\n n_guided_vocabulary_refusal --> n_agnostic_first_vocabulary\n n_derived_naming_registry --> n_declared_jurisdiction\n n_collision_consolidation --> n_one_concern_per_file\n n_sanctioned_generic_subject --> n_closed_vocabulary\n n_conformance_at_creation --> n_glob_resolvable_tree\n n_registry_held_order --> n_positional_slot_resolution\n n_externally_resolved_slot --> n_closed_vocabulary\n n_case_dialect --> n_positional_slot_resolution\n n_case_dialect --> n_closed_vocabulary" } ], "icon": "bi-collection", "id": "architecture-category-taxonomy-classification-naming", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, folder, filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that every word in a name slot comes from a declared list, and a new word enters the list only by an approved edit.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Vocabulary Admission](/records/lexicon/vocabulary-admission), [Rejection Table](/records/lexicon/rejection-table)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Reinforces" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Enables" }, { "description": "[Naming Expressiveness](/records/lexicon/naming-expressiveness)", "term": "In tension with" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Nominalized Process Word](/records/lexicon/nominalized-process-word), [Adjective Slot Word](/records/lexicon/adjective-slot-word), [Plural Subject](/records/lexicon/plural-subject), [Measurement Word](/records/lexicon/measurement-word), [Instance Identifier Word](/records/lexicon/instance-identifier-word)", "term": "Conflicts with" }, { "description": "[Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal), [Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject), [Externally Resolved Slot](/records/architecture/externally-resolved-slot), [Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" }, { "description": "[Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Contracts" }, { "description": "[Closed Vocabulary / Naming Expressiveness](/records/tension/closed-vocabulary-naming-expressiveness)", "term": "Tensions" }, { "description": "[Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary): A closed vocabulary admits a word only by approved edit, while agnostic-first decides which words to admit, domain-neutral roles before domain ones.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation)", "term": "Violated by" }, { "description": "a name slot holding a word absent from its declared array", "term": "Detected by" }, { "description": "undeclared-word count per governed root", "term": "Measured by" }, { "description": "[Rename to a Declared Word](/records/lexicon/rename-to-a-declared-word), [Vocabulary Admission](/records/lexicon/vocabulary-admission)", "term": "Refactored by" }, { "description": "registry-backed naming gate, developer approval", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/managers/foo.manager.ts → neither \"managers\" nor \"manager\" is a declared word", "kind": "code", "language": "text", "title": "Before" }, { "code": "/coordinators/foo.coordinator.ts → the declared concern that already covers the role", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "registry-backed naming gate, developer approval", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Vocabulary Admission](/records/lexicon/vocabulary-admission), [Rejection Table](/records/lexicon/rejection-table), [Single Source of Truth](/records/architecture/single-source-of-truth), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Placement Predictability](/records/lexicon/placement-predictability), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Depends on" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Nominalized Process Word](/records/lexicon/nominalized-process-word), [Adjective Slot Word](/records/lexicon/adjective-slot-word), [Plural Subject](/records/lexicon/plural-subject), [Measurement Word](/records/lexicon/measurement-word), [Instance Identifier Word](/records/lexicon/instance-identifier-word)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-closed-vocabulary", "title": "Closed Vocabulary" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that reads each word of a path by the slot it lands in, so the last dot-segment before a file's extension is always its concern and a folder named after a concern tag resolves as the latest role its depth can legally take.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concern Tag](/records/lexicon/concern-tag), [Subject Slot](/records/lexicon/subject-slot), [Ordered Role Sequence](/records/lexicon/ordered-role-sequence)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Reinforces" }, { "description": "[Variant Slot](/records/lexicon/variant-slot), [Glob Resolvability](/records/lexicon/glob-resolvability), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound), [Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Conflicts with" }, { "description": "[Registry-Held Order](/records/architecture/registry-held-order), [Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" }, { "description": "[Name Projection](/records/algorithms/name-projection)", "term": "Contracts" }, { "description": "[Case Dialect](/records/architecture/case-dialect): Positional slot resolution reads slots from dot-separated segments, while a case dialect reads the same slots from word boundaries in another case.", "term": "Distinct from" }, { "description": "[Subject Slot](/records/lexicon/subject-slot): Positional slot resolution is the reading rule, while the subject slot is one position it reads.", "term": "Distinct from" }, { "description": "[Variant Slot](/records/lexicon/variant-slot): Positional slot resolution is the reading rule, while the variant slot is one position it reads.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Vocabulary-Bound Reading](/records/lexicon/vocabulary-bound-reading)", "term": "Violated by" }, { "description": "a filename whose last segment before the extension is not a declared concern tag, or a folder carrying a concern tag's label that the resolver places in the subject role", "term": "Detected by" }, { "description": "unparseable filename count, and folders whose resolved role differs from the latest legal role for their word", "term": "Measured by" }, { "description": "[Split the Compound](/records/lexicon/split-the-compound), [Move the Tag to the Concern Slot](/records/lexicon/move-the-tag-to-the-concern-slot), [Correct the Resolver](/records/lexicon/correct-the-resolver)", "term": "Refactored by" }, { "description": "filename parser, naming gate, placement gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo-registry.ts → one fused word, so neither slot resolves", "kind": "code", "language": "text", "title": "Before" }, { "code": "foo.registry.ts → subject \"foo\", concern \"registry\"; position decides, so a concern word is legal in the subject slot too", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "filename parser, naming gate, placement gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Concern Tag](/records/lexicon/concern-tag), [Subject Slot](/records/lexicon/subject-slot), [Ordered Role Sequence](/records/lexicon/ordered-role-sequence), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Placement Predictability](/records/lexicon/placement-predictability), [Variant Slot](/records/lexicon/variant-slot), [Glob Resolvability](/records/lexicon/glob-resolvability), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Depends on" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound), [Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-positional-slot-resolution", "title": "Positional Slot Resolution" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a file's concern tag matches the label of the folder that holds it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concern Folder](/records/lexicon/concern-folder), [Concern Tag](/records/lexicon/concern-tag), [Collection Concern](/records/lexicon/collection-concern), [Single-Unit Concern](/records/lexicon/single-unit-concern), [Mass Concern](/records/lexicon/mass-concern)", "term": "Requires" }, { "description": "[Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Reinforces" }, { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Conflicts with" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Referenced by" }, { "description": "[Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Tag-Folder Mismatch](/records/lexicon/tag-folder-mismatch)", "term": "Violated by" }, { "description": "tag/folder mismatch on a filesystem walk", "term": "Detected by" }, { "description": "mismatched file count", "term": "Measured by" }, { "description": "[Move to the Matching Concern Folder](/records/lexicon/move-to-the-matching-concern-folder), [Reclassify the File](/records/lexicon/reclassify-the-file)", "term": "Refactored by" }, { "description": "placement gate, naming gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/caches/foo.store.ts → the folder says cache, the tag says store", "kind": "code", "language": "text", "title": "Before" }, { "code": "/stores/foo.store.ts → the tag terminates the name and names the parent folder", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "placement gate, naming gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Concern Folder](/records/lexicon/concern-folder), [Concern Tag](/records/lexicon/concern-tag), [Collection Concern](/records/lexicon/collection-concern), [Single-Unit Concern](/records/lexicon/single-unit-concern), [Mass Concern](/records/lexicon/mass-concern), [Glob Resolvability](/records/lexicon/glob-resolvability), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Depends on" }, { "description": "[Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-concern-folder-correspondence", "title": "Concern-Folder Correspondence" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that lets one unanchored pattern per concern collect every matching file or folder, at whatever depth it sits.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Requires" }, { "description": "[Discoverability](/records/lexicon/discoverability), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Reinforces" }, { "description": "[Shape-Discovered Surface](/records/lexicon/shape-discovered-surface)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound)", "term": "Conflicts with" }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Referenced by" }, { "description": "[Discovery Verification](/records/algorithms/discovery-verification)", "term": "Contracts" }, { "description": "[Shape-Discovered Surface](/records/lexicon/shape-discovered-surface): A glob-resolvable tree is the property that one pattern collects a concern at any depth, while a shape-discovered surface is a consumer that collects by such a pattern.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Depth-Anchored Discovery](/records/lexicon/depth-anchored-discovery)", "term": "Violated by" }, { "description": "a pattern that must enumerate depths to collect one concern", "term": "Detected by" }, { "description": "depth-anchored pattern count", "term": "Measured by" }, { "description": "[Unanchor the Pattern](/records/lexicon/unanchor-the-pattern), [Restore the Terminating Tag](/records/lexicon/restore-the-terminating-tag)", "term": "Refactored by" }, { "description": "aggregator review, placement gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/*/validators/*.ts and /*/*/validators/*.ts → one pattern per depth, and a new grouping adds another", "kind": "code", "language": "text", "title": "Before" }, { "code": "**/*.validator.ts for the files, **/validators/ for the folders → two unanchored patterns resolve the concern tree-wide", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "aggregator review, placement gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Discoverability](/records/lexicon/discoverability), [Glob Resolvability](/records/lexicon/glob-resolvability), [Shape-Discovered Surface](/records/lexicon/shape-discovered-surface)", "term": "Depends on" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-glob-resolvable-tree", "title": "Glob-Resolvable Tree" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, root, file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a naming gate reads from one declaration the roots it governs, the containers and buckets under each, the classes of file exempt from the grammar, and the trees another system authors or resolves by name, which are exempted once and never governed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Governed Root](/records/lexicon/governed-root), [Container Level](/records/lexicon/container-level), [Flat Bucket](/records/lexicon/flat-bucket), [Ignore Declaration](/records/lexicon/ignore-declaration), [Ecosystem-Fixed Name](/records/lexicon/ecosystem-fixed-name), [Structurally Exempt File](/records/lexicon/structurally-exempt-file), [Compound Marker](/records/lexicon/compound-marker)", "term": "Requires" }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Ignore-List Silencing](/records/lexicon/ignore-list-silencing), [Depth-Relief Container](/records/lexicon/depth-relief-container), [Claimed Foreign Tree](/records/lexicon/claimed-foreign-tree), [Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Conflicts with" }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Referenced by" }, { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction), [Container Ladder](/records/algorithms/container-ladder)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Shape-Inferred Jurisdiction](/records/lexicon/shape-inferred-jurisdiction), [Ignore-List Silencing](/records/lexicon/ignore-list-silencing), [Per-Check Exemption List](/records/lexicon/per-check-exemption-list)", "term": "Violated by" }, { "description": "a folder at a governed root that is in neither the container nor the bucket declaration, an ignore entry naming authored source that belongs to no exempt class, or a declared root that holds another system's ownership marker", "term": "Detected by" }, { "description": "undeclared root-level folder count, ignore entries outside the exempt classes, and exemptions held outside the one upstream declaration", "term": "Measured by" }, { "description": "[Declare the Root](/records/lexicon/declare-the-root), [Place the Folder in an Existing Container](/records/lexicon/place-the-folder-in-an-existing-container), [Remove the Ignore Entry](/records/lexicon/remove-the-ignore-entry), [Collapse the Exemption Lists](/records/lexicon/collapse-the-exemption-lists)", "term": "Refactored by" }, { "description": "jurisdiction gate, the taxonomy validator, which refuses an ignore entry of wildcards or of a whole extension, and the coordination member's declaration check, which resolves every declared upstream root against the disk and refuses a root carrying a foreign ownership marker", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "\"a folder holding no folders is a bucket\" → inferred, so a container that loses its last folder silently reclassifies and its next loose file passes", "kind": "code", "language": "text", "title": "Before" }, { "code": "containers{: [...]} + specialContainers{: [...]} → both kinds declared; a folder in neither is flagged", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "jurisdiction gate, the taxonomy validator, which refuses an ignore entry of wildcards or of a whole extension, and the coordination member's declaration check, which resolves every declared upstream root against the disk and refuses a root carrying a foreign ownership marker", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Governed Root](/records/lexicon/governed-root), [Container Level](/records/lexicon/container-level), [Flat Bucket](/records/lexicon/flat-bucket), [Ignore Declaration](/records/lexicon/ignore-declaration), [Ecosystem-Fixed Name](/records/lexicon/ecosystem-fixed-name), [Structurally Exempt File](/records/lexicon/structurally-exempt-file), [Compound Marker](/records/lexicon/compound-marker), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Source of Truth](/records/architecture/single-source-of-truth), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Depends on" }, { "description": "[Ignore-List Silencing](/records/lexicon/ignore-list-silencing), [Depth-Relief Container](/records/lexicon/depth-relief-container), [Claimed Foreign Tree](/records/lexicon/claimed-foreign-tree), [Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-declared-jurisdiction", "title": "Declared Jurisdiction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, root", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a file sits within a fixed number of folders below its governed root, with each folder taking a later role than the one above it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Depth Cap](/records/lexicon/depth-cap), [Ordered Role Sequence](/records/lexicon/ordered-role-sequence)", "term": "Requires" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Reinforces" }, { "description": "[Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Enables" }, { "description": "[Tree Compactness](/records/lexicon/tree-compactness)", "term": "In tension with" }, { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Conflicts with" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Referenced by" }, { "description": "[Path Role Walk](/records/algorithms/path-role-walk)", "term": "Contracts" }, { "description": "[Bounded Nesting Depth / Tree Compactness](/records/tension/bounded-nesting-depth-tree-compactness)", "term": "Tensions" }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility): Bounded nesting depth limits a path, while backward compatibility keeps a new version working for old consumers.", "term": "Distinct from" }, { "description": "[Depth Cap](/records/lexicon/depth-cap): Bounded nesting depth joins two conditions on a path, while the depth cap is the first, the number of folders.", "term": "Distinct from" }, { "description": "[Ordered Role Sequence](/records/lexicon/ordered-role-sequence): Bounded nesting depth joins two conditions on a path, while the ordered role sequence is the second, the order of roles.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Violated by" }, { "description": "a path over the cap, or a role repeated or revisited along it", "term": "Detected by" }, { "description": "over-cap path count", "term": "Measured by" }, { "description": "[Take the Variant Slot](/records/lexicon/take-the-variant-slot), [Add a Sibling Subject Folder](/records/lexicon/add-a-sibling-subject-folder)", "term": "Refactored by" }, { "description": "placement gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/foo/pools/lru/bar.pool.ts → one folder past the cap, and the extra level resolves to no role at all", "kind": "code", "language": "text", "title": "Before" }, { "code": "/foo/pools/bar.lru.pool.ts → container, subject, concern, in order and at the cap; the discriminator moved into the variant slot", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "placement gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Depth Cap](/records/lexicon/depth-cap), [Ordered Role Sequence](/records/lexicon/ordered-role-sequence), [Placement Predictability](/records/lexicon/placement-predictability), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Depends on" }, { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-bounded-nesting-depth", "title": "Bounded Nesting Depth" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that resolves a naming collision with the filename's variant slot and resolves breadth with a sibling subject folder.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Variant Slot](/records/lexicon/variant-slot), [Subject Folder](/records/lexicon/subject-folder)", "term": "Requires" }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Reinforces" }, { "description": "[Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Conflicts with" }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Violated by" }, { "description": "a folder level introduced where a variant or a sibling subject folder resolves the collision", "term": "Detected by" }, { "description": "nesting-relief count", "term": "Measured by" }, { "description": "[Take the Variant Slot](/records/lexicon/take-the-variant-slot), [Add a Sibling Subject Folder](/records/lexicon/add-a-sibling-subject-folder)", "term": "Refactored by" }, { "description": "placement gate, reshape review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/caches/lru/foo.cache.ts beside /caches/fifo/foo.cache.ts → the collision was relieved by a new level", "kind": "code", "language": "text", "title": "Before" }, { "code": "/caches/foo.lru.cache.ts beside /caches/foo.fifo.cache.ts → relieved by the variant slot, at the same depth", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "placement gate, reshape review", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Variant Slot](/records/lexicon/variant-slot), [Subject Folder](/records/lexicon/subject-folder), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Depends on" }, { "description": "[Downward Nesting](/records/lexicon/downward-nesting)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-sideways-overflow", "title": "Sideways Overflow" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each file plays exactly one declared role, and a file that plays two is split.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Classification Judgment](/records/lexicon/classification-judgment)", "term": "Requires" }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Reinforces" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Multi-Role File](/records/lexicon/multi-role-file), [Sentence-Shaped Name](/records/lexicon/sentence-shaped-name)", "term": "Conflicts with" }, { "description": "[Collision Consolidation](/records/architecture/collision-consolidation)", "term": "Referenced by" }, { "description": "[Collision Consolidation](/records/architecture/collision-consolidation): One concern per file splits a file that plays two roles, while collision consolidation merges two files that play one.", "term": "Distinct from" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern): One concern per file requires a single role, while narrowest concern chooses which declared role names it.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Multi-Role File](/records/lexicon/multi-role-file)", "term": "Violated by" }, { "description": "a file that classifies equally well under two declared concerns", "term": "Detected by" }, { "description": "split-candidate count", "term": "Measured by" }, { "description": "[Split by Responsibility](/records/lexicon/split-by-responsibility)", "term": "Refactored by" }, { "description": "classification review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.store.ts → holds the state AND validates every write, so its concern is two words", "kind": "code", "language": "text", "title": "Before" }, { "code": "foo.store.ts + foo.validator.ts → the ambiguity was the finding; the split is the fix", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "classification review", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Classification Judgment](/records/lexicon/classification-judgment), [Separation of Concerns](/records/architecture/separation-of-concerns), [Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Depends on" }, { "description": "[Multi-Role File](/records/lexicon/multi-role-file), [Sentence-Shaped Name](/records/lexicon/sentence-shaped-name)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-one-concern-per-file", "title": "One Concern Per File" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a file is classified under the narrowest declared role that describes it accurately.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Classification Judgment](/records/lexicon/classification-judgment)", "term": "Requires" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Reinforces" }, { "description": "[Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Conflicts with" }, { "description": "[One Concern Per File](/records/architecture/one-concern-per-file), [Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Referenced by" }, { "description": "[Concern Classification](/records/algorithms/concern-classification)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Violated by" }, { "description": "one tag carrying files of several distinct roles", "term": "Detected by" }, { "description": "files per tag, skew toward the broadest tags", "term": "Measured by" }, { "description": "[Reclassify to the Narrower Role](/records/lexicon/reclassify-to-the-narrower-role)", "term": "Refactored by" }, { "description": "classification review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.manager.ts → names a stature, so it fits lifecycle owners, caches, registries and coordinators alike", "kind": "code", "language": "text", "title": "Before" }, { "code": "foo.coordinator.ts → the narrowest declared role that is accurate; a file that cannot choose is doing both", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "classification review", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Classification Judgment](/records/lexicon/classification-judgment), [Placement Predictability](/records/lexicon/placement-predictability), [Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Depends on" }, { "description": "[Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-narrowest-concern", "title": "Narrowest Concern" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that breaks an irreducible tie between two roles in favor of the one nearer the domain on the layer spine.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Layer Spine](/records/lexicon/layer-spine)", "term": "Requires" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Reinforces" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Multi-Role File](/records/lexicon/multi-role-file)", "term": "Conflicts with" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "[Spine Read as a Dependency Rule](/records/lexicon/spine-read-as-a-dependency-rule)", "term": "Violated by" }, { "description": "an irreducible two-concern overlap resolved by preference rather than by layer", "term": "Detected by" }, { "description": "unresolved overlap count", "term": "Measured by" }, { "description": "[Apply the Domain-Ward Tie-Break](/records/lexicon/apply-the-domain-ward-tie-break)", "term": "Refactored by" }, { "description": "classification review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a file that is irreducibly both is tagged by whichever word came to mind first", "kind": "code", "language": "text", "title": "Before" }, { "code": "model (domain) beats schema (infrastructure) → domain-ward wins, and only as a tie-break after the split test fails", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "classification review", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Layer Spine](/records/lexicon/layer-spine), [Narrowest Concern](/records/architecture/narrowest-concern), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Depends on" }, { "description": "[Multi-Role File](/records/lexicon/multi-role-file)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-layer-spine-precedence", "title": "Layer Spine Precedence" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, vocabulary", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a domain-specific role word is admitted only where no domain-neutral role already covers it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Is-A Test](/records/lexicon/is-a-test), [Rejection Table](/records/lexicon/rejection-table)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Reinforces" }, { "description": "[Discoverability](/records/lexicon/discoverability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Nominalized Process Word](/records/lexicon/nominalized-process-word), [Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Conflicts with" }, { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" } ], "kind": "glossary" }, { "entries": [ { "description": "[Domain-Dialect Role](/records/lexicon/domain-dialect-role)", "term": "Violated by" }, { "description": "a domain tag whose role a declared agnostic concern already covers", "term": "Detected by" }, { "description": "domain-tag share of the vocabulary", "term": "Measured by" }, { "description": "[Classify to the Meta Concern](/records/lexicon/classify-to-the-meta-concern)", "term": "Refactored by" }, { "description": "[rejection table](/records/lexicon/rejection-table), developer approval", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/managers/ and /helpers/ → two catch-all words for roles the agnostic set already names", "kind": "code", "language": "text", "title": "Before" }, { "code": "/coordinators/ and /predicates/ → a domain tag is admitted only where no agnostic concern covers the role", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "rejection table, developer approval", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Is-A Test](/records/lexicon/is-a-test), [Rejection Table](/records/lexicon/rejection-table), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Discoverability](/records/lexicon/discoverability)", "term": "Depends on" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Nominalized Process Word](/records/lexicon/nominalized-process-word), [Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-agnostic-first-vocabulary", "title": "Agnostic-First Vocabulary" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, vocabulary, tooling", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that answers a refused word with the declared word that covers its role, looked up in an indexed rejection table.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Rejection Table](/records/lexicon/rejection-table), [Covering Concern](/records/lexicon/covering-concern), [Reverse Coverage Resolution](/records/lexicon/reverse-coverage-resolution)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Reinforces" }, { "description": "[Vocabulary Admission](/records/lexicon/vocabulary-admission), [Discoverability](/records/lexicon/discoverability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Unguided Refusal](/records/lexicon/unguided-refusal), [Borrowed Synonymy](/records/lexicon/borrowed-synonymy)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Unguided Refusal](/records/lexicon/unguided-refusal)", "term": "Violated by" }, { "description": "a refusal message naming only the rejected word, and a rejection table readable by the developer but not by the gate", "term": "Detected by" }, { "description": "share of refusals carrying a resolved replacement", "term": "Measured by" }, { "description": "[Index the Rejection Table by Refused Word](/records/lexicon/index-the-rejection-table-by-refused-word), [Name the Covering Concern in the Refusal](/records/lexicon/name-the-covering-concern-in-the-refusal)", "term": "Refactored by" }, { "description": "registry-backed naming gate, rejection-table index drift-check", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "'foo.manager.ts' → \"'manager' is not a declared concern tag\" → the developer guesses again, and the table that already answered this sits in prose no gate reads", "kind": "code", "language": "text", "title": "Before" }, { "code": "refused word → rejection-table index → \"'manager' is covered by 'coordinator'\" → foo.coordinator.ts; coverage is decided by the role a file plays, never by a general-language synonym set", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "registry-backed naming gate, rejection-table index drift-check", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Rejection Table](/records/lexicon/rejection-table), [Covering Concern](/records/lexicon/covering-concern), [Reverse Coverage Resolution](/records/lexicon/reverse-coverage-resolution), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Vocabulary Admission](/records/lexicon/vocabulary-admission), [Discoverability](/records/lexicon/discoverability)", "term": "Depends on" }, { "description": "[Unguided Refusal](/records/lexicon/unguided-refusal), [Borrowed Synonymy](/records/lexicon/borrowed-synonymy)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-guided-vocabulary-refusal", "title": "Guided Vocabulary Refusal" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, tooling", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the declared vocabulary and roots, derived from the naming document so a gate can read it, with the reasoning kept in the document.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Requires" }, { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration), [Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Reinforces" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Reasoning in the Registry](/records/lexicon/reasoning-in-the-registry)", "term": "Conflicts with" }, { "description": "[Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Prose-Only Vocabulary](/records/lexicon/prose-only-vocabulary), [Reasoning in the Registry](/records/lexicon/reasoning-in-the-registry)", "term": "Violated by" }, { "description": "a tag in the document and absent from the registry, or either way round", "term": "Detected by" }, { "description": "document/registry drift count", "term": "Measured by" }, { "description": "[Derive the Registry from the Document](/records/lexicon/derive-the-registry-from-the-document), [Move Reasoning Back to the Document](/records/lexicon/move-reasoning-back-to-the-document)", "term": "Refactored by" }, { "description": "registry/document cross-check", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "the vocabulary lives only in prose, so every gate re-reads it by hand and a rule written into the config is read by no gate", "kind": "code", "language": "text", "title": "Before" }, { "code": "document holds the reasoning → registry holds the declarations → one gate and one classifier read the registry; drift either way is a bug", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "registry/document cross-check", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Convention over Configuration](/records/architecture/convention-over-configuration), [Self-Describing Structures](/records/architecture/self-describing-structures), [Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Depends on" }, { "description": "[Reasoning in the Registry](/records/lexicon/reasoning-in-the-registry)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-derived-naming-registry", "title": "Derived Naming Registry" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a file inside a subject folder names only its own subject, because the folder already names the set.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Subject Folder](/records/lexicon/subject-folder)", "term": "Requires" }, { "description": "[Naming Consistency](/records/lexicon/naming-consistency)", "term": "Reinforces" }, { "description": "[Concise Naming](/records/lexicon/concise-naming)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Restated Set Member](/records/lexicon/restated-set-member)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Restated Set Member](/records/lexicon/restated-set-member)", "term": "Violated by" }, { "description": "a file subject equal to the subject folder above it", "term": "Detected by" }, { "description": "restated-member count", "term": "Measured by" }, { "description": "[Drop the Redundant Head](/records/lexicon/drop-the-redundant-head)", "term": "Refactored by" }, { "description": "naming gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/foo/behaviors/foo-bar.behavior.ts → restates what the folder already said", "kind": "code", "language": "text", "title": "Before" }, { "code": "/foo/behaviors/bar.behavior.ts → the folder names the set, the file names the member", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Subject Folder](/records/lexicon/subject-folder), [Naming Consistency](/records/lexicon/naming-consistency), [Concise Naming](/records/lexicon/concise-naming)", "term": "Depends on" }, { "description": "[Restated Set Member](/records/lexicon/restated-set-member)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-set-relative-member-name", "title": "Set-Relative Member Name" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: repository, refactor", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for renaming files one container at a time by hand, re-pointing each pattern and comparing what each aggregator collects before and after.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Identity Migration](/records/lexicon/identity-migration), [Shape-Discovered Surface](/records/lexicon/shape-discovered-surface), [Conversion Record](/records/lexicon/conversion-record), [Alignment Entry](/records/lexicon/alignment-entry), [Re-Alignment Cadence](/records/lexicon/re-alignment-cadence), [Frozen Baseline](/records/lexicon/frozen-baseline), [Unreferenced Export Triage](/records/lexicon/unreferenced-export-triage)", "term": "Requires" }, { "description": "[Container-by-Container Reshape](/records/lexicon/container-by-container-reshape)", "term": "Reinforces" }, { "description": "[Maintainability](/records/lexicon/maintainability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Automated Reshape](/records/lexicon/automated-reshape)", "term": "Conflicts with" }, { "description": "[Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Container Reshape](/records/algorithms/container-reshape), [Export Triage Ladder](/records/algorithms/export-triage-ladder), [Alignment Cadence](/records/algorithms/alignment-cadence)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Automated Reshape](/records/lexicon/automated-reshape)", "term": "Violated by" }, { "description": "a shape-discovered surface whose collected count changed across a rename", "term": "Detected by" }, { "description": "collected-member delta per aggregator", "term": "Measured by" }, { "description": "[Re-Point the Pattern](/records/lexicon/re-point-the-pattern), [Verify the Collected Count](/records/lexicon/verify-the-collected-count)", "term": "Refactored by" }, { "description": "per-container reshape review, gate green between containers", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a rename tool rewrites every literal path; **/*.validator.ts now collects nothing and the gate stays green because nothing is left to check", "kind": "code", "language": "text", "title": "Before" }, { "code": "one container → rename → update every importer → re-point every pattern → compare collected counts against the previous run → gate green before the next container", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "per-container reshape review, gate green between containers", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Identity Migration](/records/lexicon/identity-migration), [Shape-Discovered Surface](/records/lexicon/shape-discovered-surface), [Conversion Record](/records/lexicon/conversion-record), [Alignment Entry](/records/lexicon/alignment-entry), [Re-Alignment Cadence](/records/lexicon/re-alignment-cadence), [Frozen Baseline](/records/lexicon/frozen-baseline), [Unreferenced Export Triage](/records/lexicon/unreferenced-export-triage), [Container-by-Container Reshape](/records/lexicon/container-by-container-reshape), [Maintainability](/records/lexicon/maintainability)", "term": "Depends on" }, { "description": "[Automated Reshape](/records/lexicon/automated-reshape)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-manual-identity-migration", "title": "Manual Identity Migration" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a filename already held by another file is first read as a sign that both files do the same job, and a variant is added only after the code shows that their jobs differ.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Variant Slot](/records/lexicon/variant-slot), [One Concern Per File](/records/architecture/one-concern-per-file)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Reinforces" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Variant-Masked Duplicate](/records/lexicon/variant-masked-duplicate)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Variant-Masked Duplicate](/records/lexicon/variant-masked-duplicate)", "term": "Violated by" }, { "description": "a variant whose sibling in the same folder shares its concern and one of its responsibilities", "term": "Detected by" }, { "description": "variants admitted without a consolidation verdict", "term": "Measured by" }, { "description": "[Compare Both Files](/records/lexicon/compare-both-files), [Merge One Job or Name the Facet](/records/lexicon/merge-one-job-or-name-the-facet)", "term": "Refactored by" }, { "description": "the duplicates verdict each conversion record carries, reviewed per file", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.validator.ts exists → the new file becomes foo.extra.validator.ts, and both run the same checks under two names", "kind": "code", "language": "text", "title": "Before" }, { "code": "the name is taken → both files are read → one job: merged into foo.validator.ts; two jobs: the variant names the facet the code shows", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the duplicates verdict each conversion record carries, reviewed per file", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Variant Slot](/records/lexicon/variant-slot), [One Concern Per File](/records/architecture/one-concern-per-file), [Single Source of Truth](/records/architecture/single-source-of-truth), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Depends on" }, { "description": "[Variant-Masked Duplicate](/records/lexicon/variant-masked-duplicate)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-collision-consolidation", "title": "Collision Consolidation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: folder, file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a test sits in the concern folder of the file it tests, under a test root mirroring that file's governed root, and moves whenever that file moves.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Compound Marker](/records/lexicon/compound-marker), [Concern Folder](/records/lexicon/concern-folder)", "term": "Requires" }, { "description": "[Discoverability](/records/lexicon/discoverability)", "term": "Reinforces" }, { "description": "[Identity Migration](/records/lexicon/identity-migration)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Stranded Test](/records/lexicon/stranded-test)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Stranded Test](/records/lexicon/stranded-test), [Shared-Subject Test](/records/lexicon/shared-subject-test)", "term": "Violated by" }, { "description": "a test whose path does not mirror the concern folder of the file it names", "term": "Detected by" }, { "description": "tests off their mirrored path", "term": "Measured by" }, { "description": "[Move the Test with Its Subject](/records/lexicon/move-the-test-with-its-subject), [Split One Test per Subject](/records/lexicon/split-one-test-per-subject)", "term": "Refactored by" }, { "description": "the centralized-test and subjectless-test checks, and the taxonomy step's mirror check", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/validators/foo.validator.ts moves to /predicates/foo.predicate.ts → its test stays under the old validators mirror", "kind": "code", "language": "text", "title": "Before" }, { "code": "/predicates/foo.predicate.test.ts → the test moves in the same pass and names the file it now covers", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the centralized-test and subjectless-test checks, and the taxonomy step's mirror check", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Compound Marker](/records/lexicon/compound-marker), [Concern Folder](/records/lexicon/concern-folder), [Discoverability](/records/lexicon/discoverability), [Identity Migration](/records/lexicon/identity-migration)", "term": "Depends on" }, { "description": "[Stranded Test](/records/lexicon/stranded-test)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-mirrored-test-placement", "title": "Mirrored Test Placement" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a file takes the one generic subject only when it is generic over its type parameters and names no domain noun anywhere in its source.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Subject Slot](/records/lexicon/subject-slot)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Reinforces" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Grouping Label](/records/lexicon/grouping-label)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Generic Subject over a Domain File](/records/lexicon/generic-subject-over-a-domain-file)", "term": "Violated by" }, { "description": "a file carrying the generic subject whose source names a domain noun", "term": "Detected by" }, { "description": "generic-subject files that fail either test", "term": "Measured by" }, { "description": "[Take the Domain Noun as the Subject](/records/lexicon/take-the-domain-noun-as-the-subject)", "term": "Refactored by" }, { "description": "classification review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "base.cache.ts → holds a cache typed to invoices and sessions, so the generic name hides two subjects", "kind": "code", "language": "text", "title": "Before" }, { "code": "base.lru.cache.ts for the cache generic over its keys and values, and invoice.cache.ts for the one that names invoices", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "classification review", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Subject Slot](/records/lexicon/subject-slot), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Placement Predictability](/records/lexicon/placement-predictability)", "term": "Depends on" }, { "description": "[Grouping Label](/records/lexicon/grouping-label)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-sanctioned-generic-subject", "title": "Sanctioned Generic Subject" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: file", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that a file created under a governed root is named and placed correctly when it is first written, so no conversion queue accumulates behind new work.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Governed Root](/records/lexicon/governed-root), [Classification Judgment](/records/lexicon/classification-judgment)", "term": "Requires" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Reinforces" }, { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Automated Reshape](/records/lexicon/automated-reshape)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Provisional Name](/records/lexicon/provisional-name)", "term": "Violated by" }, { "description": "a newly created file that the naming or placement gate refuses", "term": "Detected by" }, { "description": "new files refused on their first run", "term": "Measured by" }, { "description": "[Classify Before the First Write](/records/lexicon/classify-before-the-first-write)", "term": "Refactored by" }, { "description": "naming gate, placement gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a new helper lands as temp.ts, to be renamed later, and three importers bind to the temporary name", "kind": "code", "language": "text", "title": "Before" }, { "code": "the file is read into its role before it is written → foo.formatter.ts in formatters/ from the first commit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming gate, placement gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Governed Root](/records/lexicon/governed-root), [Classification Judgment](/records/lexicon/classification-judgment), [Placement Predictability](/records/lexicon/placement-predictability), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Depends on" }, { "description": "[Automated Reshape](/records/lexicon/automated-reshape)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-conformance-at-creation", "title": "Conformance at Creation" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that load or execution order is held by an import list or a registry, so a filename carries no numeric prefix the grammar would have to parse.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Requires" }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Reinforces" }, { "description": "[Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Numeric Order Prefix](/records/lexicon/numeric-order-prefix)", "term": "Conflicts with" }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration): Registry-held order keeps sequence out of filenames, while declarative configuration keeps settings in validated data.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Numeric Order Prefix](/records/lexicon/numeric-order-prefix)", "term": "Violated by" }, { "description": "a filename whose first segment is a number", "term": "Detected by" }, { "description": "numerically prefixed filenames", "term": "Measured by" }, { "description": "[Move the Order into the Registry](/records/lexicon/move-the-order-into-the-registry), [Drop the Prefix](/records/lexicon/drop-the-prefix)", "term": "Refactored by" }, { "description": "naming gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "01-setup.step.ts, 02-build.step.ts → inserting a step renumbers every name after it", "kind": "code", "language": "text", "title": "Before" }, { "code": "setup.step.ts, build.step.ts, and the order held once in the registry that runs them", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Declarative Configuration](/records/architecture/declarative-configuration), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Depends on" }, { "description": "[Numeric Order Prefix](/records/lexicon/numeric-order-prefix)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-registry-held-order", "title": "Registry-Held Order" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: root, filename, vocabulary", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that resolves a name slot whose words another source owns against that source, whether an index that allocates identities, an upstream key set or a field the file itself carries, so the closed vocabulary never holds a copy of them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Variant Slot](/records/lexicon/variant-slot), [Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Requires" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Determinism](/records/architecture/determinism)", "term": "Reinforces" }, { "description": "[Stable Identity](/records/lexicon/stable-identity), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Conflicts with" } ], "kind": "glossary" }, { "entries": [ { "description": "[Copied Slot Word](/records/lexicon/copied-slot-word)", "term": "Violated by" }, { "description": "a vocabulary entry that mirrors a row of an allocating index, or a corpus file whose facet segment differs from the facet its own field declares", "term": "Detected by" }, { "description": "slot words held both in the vocabulary and in the source that owns them", "term": "Measured by" }, { "description": "[Resolve the Slot Against Its Source](/records/lexicon/resolve-the-slot-against-its-source), [Remove the Copies](/records/lexicon/remove-the-copies)", "term": "Refactored by" }, { "description": "the coordination member's slot check, which resolves a seat letter against the index that allocates it", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "each new seat letter is added to the variants array → the array and the index disagree as soon as one moves", "kind": "code", "language": "text", "title": "Before" }, { "code": "the variant slot resolves against the index that allocates letters → a new seat needs no vocabulary edit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's slot check, which resolves a seat letter against the index that allocates it", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Variant Slot](/records/lexicon/variant-slot), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Single Source of Truth](/records/architecture/single-source-of-truth), [Determinism](/records/architecture/determinism), [Stable Identity](/records/lexicon/stable-identity), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Depends on" }, { "description": "[Vocabulary Inflation](/records/lexicon/vocabulary-inflation), [Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-externally-resolved-slot", "title": "Externally Resolved Slot" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: filename", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that binds file extensions to the case their language names files in and reads the same subject, variant and concern slots from the stem's word boundaries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Word-Boundary Case](/records/lexicon/word-boundary-case), [Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Requires" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Portability](/records/architecture/portability)", "term": "Reinforces" }, { "description": "[Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound)", "term": "Conflicts with" }, { "description": "[Dialect Resolution](/records/algorithms/dialect-resolution)", "term": "Contracts" } ], "kind": "glossary" }, { "entries": [ { "description": "[Per-Language Vocabulary](/records/lexicon/per-language-vocabulary)", "term": "Violated by" }, { "description": "a dialect file whose trailing words are not a declared concern tag, or a dialect naming a case no splitter reads", "term": "Detected by" }, { "description": "dialect files that do not resolve to three declared slots", "term": "Measured by" }, { "description": "[Declare the Dialect](/records/lexicon/declare-the-dialect), [Rename to the Case's Word Run](/records/lexicon/rename-to-the-case-s-word-run)", "term": "Refactored by" }, { "description": "naming gate, which parses a dialect's word run, and the taxonomy validator, which refuses a case no splitter reads", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "a language that names files in pascal case falls outside the grammar, so its files are ignored or forced into dotted kebab names its tools do not find", "kind": "code", "language": "text", "title": "Before" }, { "code": "SessionRefreshValidator. under a pascal dialect → words session, refresh, validator → subject session, variant refresh, concern validator, and its folder stays kebab", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "naming gate, which parses a dialect's word run, and the taxonomy validator, which refuses a case no splitter reads", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Word-Boundary Case](/records/lexicon/word-boundary-case), [Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Closed Vocabulary](/records/architecture/closed-vocabulary), [Portability](/records/architecture/portability), [Glob Resolvability](/records/lexicon/glob-resolvability)", "term": "Depends on" }, { "description": "[Concern-Swallowing Compound](/records/lexicon/concern-swallowing-compound)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-case-dialect", "title": "Case Dialect" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/architecture-category/taxonomy-classification-naming)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: root", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a governed root carries only its entry document and its accumulators at the root, and every other file sits in a concern folder.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Governed Root](/records/lexicon/governed-root), [Concern Folder](/records/lexicon/concern-folder)", "term": "Requires" }, { "description": "[Placement Predictability](/records/lexicon/placement-predictability)", "term": "Reinforces" }, { "description": "[Discoverability](/records/lexicon/discoverability)", "term": "Enables" }, { "description": "none", "term": "In tension with" }, { "description": "[Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Conflicts with" }, { "description": "[Governed Root](/records/lexicon/governed-root): Root spine files limit which files may sit at a governed root, while the governed root is the declaration that brings a tree under the taxonomy.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Loose Root File](/records/lexicon/loose-root-file)", "term": "Violated by" }, { "description": "a loose file at a governed root", "term": "Detected by" }, { "description": "loose root files", "term": "Measured by" }, { "description": "[Move the File into Its Concern Folder](/records/lexicon/move-the-file-into-its-concern-folder)", "term": "Refactored by" }, { "description": "placement gate", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "/notes.ts beside /README.md → the loose file resolves to no role", "kind": "code", "language": "text", "title": "Before" }, { "code": "/README.md and the underscore-marked accumulators stay; every other file moves to ///", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "placement gate", "term": "Checked by" }, { "description": "Every folder and filename under a declared governed root, and every word in the declared vocabularies", "term": "Population" }, { "description": "A verdict stands until a file is added, moved or renamed, or a vocabulary or root declaration changes", "term": "Freshness" }, { "description": "The naming or placement gate fails the lint run on the file, naming the declared word that covers a refused one", "term": "Refusal" }, { "description": "Each path parsed by position against the declared containers, depth cap and closed vocabularies", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Governed Root](/records/lexicon/governed-root), [Concern Folder](/records/lexicon/concern-folder), [Placement Predictability](/records/lexicon/placement-predictability), [Discoverability](/records/lexicon/discoverability)", "term": "Depends on" }, { "description": "[Free-Form Folder Level](/records/lexicon/free-form-folder-level)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-root-spine-files", "title": "Root Spine Files" } ], "title": "Taxonomy / Classification / Naming" }, { "blocks": [ { "caption": "The relations inside this category.", "kind": "mermaid", "text": "flowchart LR\n n_idempotency[\"Idempotency\"]\n n_atomicity[\"Atomicity\"]\n n_acid[\"ACID\"]\n n_transaction_boundary[\"Transaction Boundary\"]\n n_unit_of_work_pattern[\"Unit of Work Pattern\"]\n n_consistency[\"Consistency\"]\n n_isolation[\"Isolation\"]\n n_concurrency_control[\"Concurrency Control\"]\n n_optimistic_locking[\"Optimistic Locking\"]\n n_pessimistic_locking[\"Pessimistic Locking\"]\n n_state_isolation[\"State Isolation\"]\n n_controlled_side_effects[\"Controlled Side Effects\"]\n n_petri_nets[\"Petri Nets\"]\n n_atomicity --> n_transaction_boundary\n n_atomicity --> n_consistency\n n_acid --> n_atomicity\n n_acid --> n_consistency\n n_acid --> n_isolation\n n_transaction_boundary --> n_atomicity\n n_transaction_boundary --> n_unit_of_work_pattern\n n_unit_of_work_pattern --> n_transaction_boundary\n n_unit_of_work_pattern --> n_atomicity\n n_unit_of_work_pattern --> n_consistency\n n_isolation --> n_concurrency_control\n n_concurrency_control --> n_isolation\n n_optimistic_locking --> n_concurrency_control\n n_pessimistic_locking --> n_isolation" } ], "icon": "bi-collection", "id": "architecture-category-transactions-state-concurrency", "intro": "Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.", "subsections": [ { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: API, command, message handler", "Aliases: Idempotence", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that repeating an operation with the same input has the same effect as running it once.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Idempotency Key or Deterministic Operation](/records/lexicon/idempotency-key-or-deterministic-operation)", "term": "Requires" }, { "description": "[Retry Safety](/records/lexicon/retry-safety), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Reinforces" }, { "description": "[Safe Retries](/records/lexicon/safe-retries)", "term": "Enables" }, { "description": "[State Tracking](/records/lexicon/state-tracking)", "term": "In tension with" }, { "description": "[Non-Repeatable Side Effects](/records/lexicon/non-repeatable-side-effects)", "term": "Conflicts with" }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Eventual Consistency](/records/architecture/eventual-consistency), [Saga Pattern](/records/architecture/saga-pattern), [Retry Pattern](/records/architecture/retry-pattern), [Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" }, { "description": "[Idempotency / State Tracking](/records/tension/idempotency-state-tracking)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Non-Idempotent Operation](/records/lexicon/non-idempotent-operation), [Duplicate Side Effects](/records/lexicon/duplicate-side-effects)", "term": "Violated by" }, { "description": "side-effectful handlers without deduplication", "term": "Detected by" }, { "description": "duplicate-effect defect rate", "term": "Measured by" }, { "description": "[Idempotency Key](/records/lexicon/idempotency-key), [Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Refactored by" }, { "description": "retry tests, API policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "app.post(\"/foo\", async request => fooStore.create(await request.json()));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "app.post(\"/foo\", async request => {\n const key = requireHeader(request, \"Idempotency-Key\");\n const body = await request.json();\n return idempotency.execute(key, () => fooStore.create(body));\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "retry tests, API policy", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Idempotency Key or Deterministic Operation](/records/lexicon/idempotency-key-or-deterministic-operation), [Retry Safety](/records/lexicon/retry-safety), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Safe Retries](/records/lexicon/safe-retries)", "term": "Depends on" }, { "description": "[Non-Repeatable Side Effects](/records/lexicon/non-repeatable-side-effects)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-idempotency", "title": "Idempotency" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: transaction, operation, workflow", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that the steps of a state change either all take effect or none do.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Requires" }, { "description": "[Consistency](/records/architecture/consistency), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[All-or-Nothing State Change](/records/lexicon/all-or-nothing-state-change)", "term": "Enables" }, { "description": "[Distributed Scalability](/records/lexicon/distributed-scalability)", "term": "In tension with" }, { "description": "[Partial Commit](/records/lexicon/partial-commit)", "term": "Conflicts with" }, { "description": "[ACID](/records/architecture/acid), [Transaction Boundary](/records/architecture/transaction-boundary), [Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" }, { "description": "[Atomic Boundary](/records/algorithms/atomic-boundary)", "term": "Contracts" }, { "description": "[Atomicity / Distributed Scalability](/records/tension/atomicity-distributed-scalability)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Partial Commit](/records/lexicon/partial-commit)", "term": "Violated by" }, { "description": "multi-step writes without transaction/compensation", "term": "Detected by" }, { "description": "partial failure rate", "term": "Measured by" }, { "description": "[Introduce Transaction Boundary](/records/lexicon/introduce-transaction-boundary), [Saga Pattern](/records/architecture/saga-pattern), [Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Refactored by" }, { "description": "transaction tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooStore.remove(from, foo.id);\nawait fooStore.add(to, foo.id);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await database.transaction(async tx => {\n await tx.foos.remove(from, foo.id);\n await tx.foos.add(to, foo.id);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "transaction tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary), [Consistency](/records/architecture/consistency), [Correctness](/records/architecture/correctness), [All-or-Nothing State Change](/records/lexicon/all-or-nothing-state-change)", "term": "Depends on" }, { "description": "[Partial Commit](/records/lexicon/partial-commit)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-atomicity", "title": "Atomicity" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: database, transaction", "Aliases: Atomicity, Consistency, Isolation, Durability", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the four guarantees of a database transaction: atomicity, consistency, isolation and durability.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Atomicity](/records/architecture/atomicity), [Consistency](/records/architecture/consistency), [Isolation](/records/architecture/isolation), [Durability](/records/lexicon/durability)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Strong Transactional Guarantees](/records/lexicon/strong-transactional-guarantees)", "term": "Enables" }, { "description": "[Distributed Availability](/records/lexicon/distributed-availability), [BASE/Eventual Consistency](/records/lexicon/base-eventual-consistency)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[ACID / Distributed Availability](/records/tension/acid-distributed-availability), [ACID / BASE/Eventual Consistency](/records/tension/acid-base-eventual-consistency)", "term": "Tensions" }, { "description": "[BASE/Eventual Consistency](/records/lexicon/base-eventual-consistency): ACID keeps each transaction atomic, consistent, isolated and durable, while BASE favors availability and lets replicas converge later.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Partial Commit](/records/lexicon/partial-commit)", "term": "Violated by" }, { "description": "non-transactional multi-write invariants", "term": "Detected by" }, { "description": "transactional invariant defects", "term": "Measured by" }, { "description": "[Introduce Transaction Boundary](/records/lexicon/introduce-transaction-boundary), [Invariant Check](/records/lexicon/invariant-check)", "term": "Refactored by" }, { "description": "DB transactions, isolation tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooDb.write(foo);\nawait barDb.write(bar);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await database.transaction({ isolation: \"serializable\" }, async tx => {\n await tx.foos.save(foo);\n await tx.bars.save(bar);\n assertInvariant(foo, bar);\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "DB transactions, isolation tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Atomicity](/records/architecture/atomicity), [Consistency](/records/architecture/consistency), [Isolation](/records/architecture/isolation), [Durability](/records/lexicon/durability), [Correctness](/records/architecture/correctness), [Strong Transactional Guarantees](/records/lexicon/strong-transactional-guarantees)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-acid", "title": "ACID" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: unit of work, aggregate, service", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a transaction covers exactly the writes of one unit of work inside one service.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Consistency Rules](/records/lexicon/consistency-rules)", "term": "Requires" }, { "description": "[Atomicity](/records/architecture/atomicity), [Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Reinforces" }, { "description": "[Safe State Mutation](/records/lexicon/safe-state-mutation)", "term": "Enables" }, { "description": "[Large Transaction Scope](/records/lexicon/large-transaction-scope)", "term": "In tension with" }, { "description": "[Hidden Distributed Transaction](/records/lexicon/hidden-distributed-transaction)", "term": "Conflicts with" }, { "description": "[Atomicity](/records/architecture/atomicity), [Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" }, { "description": "[Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Contracts" }, { "description": "[Transaction Boundary / Large Transaction Scope](/records/tension/large-transaction-scope-transaction-boundary)", "term": "Tensions" }, { "description": "[Consistency Rules](/records/lexicon/consistency-rules): A transaction boundary fixes which writes one transaction covers, while consistency rules are the invariants it must keep inside that scope.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Distributed Transaction](/records/lexicon/hidden-distributed-transaction)", "term": "Violated by" }, { "description": "transaction scope leakage", "term": "Detected by" }, { "description": "transaction size/duration", "term": "Measured by" }, { "description": "[Restrict Exports](/records/lexicon/restrict-exports), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Refactored by" }, { "description": "transaction policy", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await beginTransaction();\nawait controller.parse(request);\nawait service.validate(foo);\nawait repository.save(foo);\nawait commitTransaction();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "async function createFoo(input: CreateFoo) {\n const foo = validateFoo(input);\n return database.transaction(tx => new FooRepository(tx).save(foo));\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "transaction policy", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Consistency Rules](/records/lexicon/consistency-rules), [Atomicity](/records/architecture/atomicity), [Unit of Work Pattern](/records/architecture/unit-of-work-pattern), [Safe State Mutation](/records/lexicon/safe-state-mutation)", "term": "Depends on" }, { "description": "[Hidden Distributed Transaction](/records/lexicon/hidden-distributed-transaction)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-transaction-boundary", "title": "Transaction Boundary" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: application service, persistence", "Aliases: Unit of Work", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that collects the changes of one use case and commits them together in a single transaction.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Requires" }, { "description": "[Atomicity](/records/architecture/atomicity), [Consistency](/records/architecture/consistency)", "term": "Reinforces" }, { "description": "[Coordinated Persistence](/records/lexicon/coordinated-persistence)", "term": "Enables" }, { "description": "[Repository Complexity](/records/lexicon/repository-complexity)", "term": "In tension with" }, { "description": "[Scattered Save Calls](/records/lexicon/scattered-save-calls)", "term": "Conflicts with" }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Referenced by" }, { "description": "[Unit of Work Pattern / Repository Complexity](/records/tension/repository-complexity-unit-of-work-pattern)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Scattered Save Calls](/records/lexicon/scattered-save-calls)", "term": "Violated by" }, { "description": "multiple independent saves in one use case", "term": "Detected by" }, { "description": "save coordination defects", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "persistence conventions", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooRepository.save(foo);\nawait barRepository.save(bar);\nawait eventRepository.save(event);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const uow = unitOfWork.begin();\nuow.foos.save(foo);\nuow.bars.save(bar);\nuow.events.append(event);\nawait uow.commit();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "persistence conventions", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary), [Atomicity](/records/architecture/atomicity), [Consistency](/records/architecture/consistency), [Coordinated Persistence](/records/lexicon/coordinated-persistence)", "term": "Depends on" }, { "description": "[Scattered Save Calls](/records/lexicon/scattered-save-calls)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-unit-of-work-pattern", "title": "Unit of Work Pattern" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: data, transaction, distributed system", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which stored data satisfies its invariants after every change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Invariant](/records/architecture/invariant), [Validation](/records/architecture/validation)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Reliable State](/records/lexicon/reliable-state)", "term": "Enables" }, { "description": "[Availability](/records/lexicon/availability), [Latency](/records/architecture/latency)", "term": "In tension with" }, { "description": "[Inconsistent Replicas/Models](/records/lexicon/inconsistent-replicas-models)", "term": "Conflicts with" }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast), [Invariant](/records/architecture/invariant), [Centralized Configuration](/records/architecture/centralized-configuration), [Decentralization](/records/architecture/decentralization), [Consensus](/records/architecture/consensus), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Code Review](/records/architecture/code-review), [Reference Architecture](/records/architecture/reference-architecture), [Standardization](/records/architecture/standardization), [Scalability](/records/architecture/scalability), [Caching](/records/architecture/caching), [Failover](/records/architecture/failover), [Single Source of Truth](/records/architecture/single-source-of-truth), [Normalization](/records/architecture/normalization), [Governance](/records/architecture/governance), [Microservices](/records/architecture/microservices), [Space-Based Architecture](/records/architecture/space-based-architecture), [Atomicity](/records/architecture/atomicity), [ACID](/records/architecture/acid), [Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" }, { "description": "[Consistency / Availability](/records/tension/availability-consistency), [Consistency / Latency](/records/tension/consistency-latency)", "term": "Tensions" }, { "description": "[Correctness](/records/architecture/correctness): Consistency is stored data satisfying its invariants, while correctness is code behavior matching its specification.", "term": "Distinct from" }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance): Consistency is data keeping its invariants, while fault tolerance is operation continuing through component failure.", "term": "Distinct from" }, { "description": "[Interoperability](/records/architecture/interoperability): Consistency is data inside one system keeping its invariants, while interoperability is separate systems exchanging data.", "term": "Distinct from" }, { "description": "[Always-Fresh Reads](/records/lexicon/always-fresh-reads): Consistency is invariants holding after every change, while always-fresh reads is every read seeing the latest write.", "term": "Distinct from" }, { "description": "[Availability](/records/lexicon/availability): Consistency is data keeping its invariants, while availability is the system answering at all.", "term": "Distinct from" }, { "description": "[Durability](/records/lexicon/durability): Consistency is invariants holding after a change, while durability is a committed change surviving a crash.", "term": "Distinct from" }, { "description": "[Maintainability](/records/lexicon/maintainability): Consistency is a property of stored data, while maintainability is a property of the code that changes it.", "term": "Distinct from" }, { "description": "[Scalability](/records/architecture/scalability): Consistency is invariants holding, while scalability is performance holding as load grows.", "term": "Distinct from" }, { "description": "[Operational Complexity](/records/lexicon/operational-complexity): Consistency is invariants holding, while operational complexity is the effort of running the system in production.", "term": "Distinct from" }, { "description": "[Quality](/records/lexicon/quality): Consistency is one property of stored data, while quality is how far a system meets all its expectations.", "term": "Distinct from" }, { "description": "[Security](/records/lexicon/security): Consistency is data keeping its invariants, while security is protection from misuse and attack.", "term": "Distinct from" }, { "description": "[Simplicity](/records/lexicon/simplicity): Consistency is invariants holding, while simplicity is the absence of unneeded structure.", "term": "Distinct from" } ], "kind": "glossary" }, { "entries": [ { "description": "[Reachable Invalid State](/records/lexicon/reachable-invalid-state)", "term": "Violated by" }, { "description": "data anomalies, failed invariant checks", "term": "Detected by" }, { "description": "consistency violation count", "term": "Measured by" }, { "description": "[Invariant Check](/records/lexicon/invariant-check), [Introduce Transaction Boundary](/records/lexicon/introduce-transaction-boundary), [Reconciliation Job](/records/lexicon/reconciliation-job)", "term": "Refactored by" }, { "description": "database constraints, invariant tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "foo.total = foo.items.reduce((sum, item) => sum + item.value, 0);\nfoo.itemCount = externalCount;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function rebuildFoo(items: readonly FooItem[]): Foo {\n return { items, total: sum(items), itemCount: items.length };\n}\nconst foo = rebuildFoo(items);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "database constraints, invariant tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Invariant](/records/architecture/invariant), [Validation](/records/architecture/validation), [Correctness](/records/architecture/correctness), [Reliable State](/records/lexicon/reliable-state)", "term": "Depends on" }, { "description": "[Inconsistent Replicas/Models](/records/lexicon/inconsistent-replicas-models)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-consistency", "title": "Consistency" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: database, transaction, concurrency", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that concurrent transactions do not see each other's uncommitted changes, to the degree the isolation level declares.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Requires" }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Safe Concurrent Operations](/records/lexicon/safe-concurrent-operations)", "term": "Enables" }, { "description": "[Throughput](/records/architecture/throughput)", "term": "In tension with" }, { "description": "[Dirty Reads/Writes](/records/lexicon/dirty-reads-writes)", "term": "Conflicts with" }, { "description": "[Partitioning](/records/architecture/partitioning), [ACID](/records/architecture/acid), [Concurrency Control](/records/architecture/concurrency-control), [Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Referenced by" }, { "description": "[Isolation / Throughput](/records/tension/isolation-throughput)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Dirty Reads/Writes](/records/lexicon/dirty-reads-writes)", "term": "Violated by" }, { "description": "concurrency tests, isolation anomalies", "term": "Detected by" }, { "description": "anomaly rate, lock contention", "term": "Measured by" }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking), [Transaction Isolation Level](/records/lexicon/transaction-isolation-level)", "term": "Refactored by" }, { "description": "DB isolation, concurrency tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await fooStore.find(id);\nfoo.count += 1;\nawait fooStore.save(foo);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await database.transaction({ isolation: \"serializable\" }, async tx => {\n const foo = await tx.foos.lock(id);\n await tx.foos.save({ ...foo, count: foo.count + 1 });\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "DB isolation, concurrency tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Concurrency Control](/records/architecture/concurrency-control), [Correctness](/records/architecture/correctness), [Safe Concurrent Operations](/records/lexicon/safe-concurrent-operations)", "term": "Depends on" }, { "description": "[Dirty Reads/Writes](/records/lexicon/dirty-reads-writes)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-isolation", "title": "Isolation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: transaction, memory, distributed system", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A mechanism that coordinates concurrent access to shared state, through locks, versions or compare-and-swap.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Shared State Identification](/records/lexicon/shared-state-identification)", "term": "Requires" }, { "description": "[Isolation](/records/architecture/isolation), [Correctness](/records/architecture/correctness)", "term": "Reinforces" }, { "description": "[Safe Parallel Mutation](/records/lexicon/safe-parallel-mutation)", "term": "Enables" }, { "description": "[Performance](/records/lexicon/performance)", "term": "In tension with" }, { "description": "[Race Conditions](/records/lexicon/race-conditions), [Lost Update](/records/architecture/lost-update)", "term": "Conflicts with" }, { "description": "[Concurrency](/records/architecture/concurrency), [Isolation](/records/architecture/isolation), [Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Referenced by" }, { "description": "[Concurrency Control / Performance](/records/tension/concurrency-control-performance)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Race Conditions](/records/lexicon/race-conditions)", "term": "Violated by" }, { "description": "race detectors, flaky concurrent tests", "term": "Detected by" }, { "description": "race count, contention", "term": "Measured by" }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking), [Make Immutable](/records/lexicon/make-immutable), [Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Refactored by" }, { "description": "thread-safety analysis, [tests](/records/lexicon/tests)", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await fooStore.find(id);\nawait fooStore.save({ ...foo, count: foo.count + 1 });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await fooStore.update(id, current => ({\n ...current,\n count: current.count + 1,\n}), { expectedVersion: foo.version });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "thread-safety analysis, tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Shared State Identification](/records/lexicon/shared-state-identification), [Isolation](/records/architecture/isolation), [Correctness](/records/architecture/correctness), [Safe Parallel Mutation](/records/lexicon/safe-parallel-mutation)", "term": "Depends on" }, { "description": "[Race Conditions](/records/lexicon/race-conditions), [Lost Update](/records/architecture/lost-update)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-concurrency-control", "title": "Concurrency Control" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: persistence, transaction", "Aliases: Own-Span Compare-and-Swap", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that checks a record's version when it is written and rejects the write if another writer changed it first, comparing only the writer's own span where a surface is fenced per writer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Version Field](/records/lexicon/version-field)", "term": "Requires" }, { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Reinforces" }, { "description": "[Conflict Detection](/records/lexicon/conflict-detection)", "term": "Enables" }, { "description": "[Retry Complexity](/records/lexicon/retry-complexity)", "term": "In tension with" }, { "description": "[Blind Overwrite](/records/lexicon/blind-overwrite)", "term": "Conflicts with" }, { "description": "[Write Barrier](/records/architecture/write-barrier)", "term": "Referenced by" }, { "description": "[Optimistic Locking / Retry Complexity](/records/tension/optimistic-locking-retry-complexity)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Violated by" }, { "description": "updates without version check", "term": "Detected by" }, { "description": "conflict/retry rate", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "repository rules, integration tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "await fooTable.update({ id: foo.id, name: foo.name });", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const updated = await fooTable.update({\n id: foo.id,\n expectedVersion: foo.version,\n next: { ...foo, version: foo.version + 1 },\n});\nif (!updated) throw new ConflictError(foo.id);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "repository rules, integration tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Version Field](/records/lexicon/version-field), [Concurrency Control](/records/architecture/concurrency-control), [Conflict Detection](/records/lexicon/conflict-detection)", "term": "Depends on" }, { "description": "[Blind Overwrite](/records/lexicon/blind-overwrite)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-optimistic-locking", "title": "Optimistic Locking" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: persistence, critical section", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design pattern that locks a record before reading it for update, so other writers wait until the transaction ends.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Lock Ownership](/records/lexicon/lock-ownership)", "term": "Requires" }, { "description": "[Isolation](/records/architecture/isolation)", "term": "Reinforces" }, { "description": "[Strong Conflict Prevention](/records/lexicon/strong-conflict-prevention)", "term": "Enables" }, { "description": "[Deadlock Freedom](/records/lexicon/deadlock-freedom), [Latency](/records/architecture/latency), [Lock-Free Throughput](/records/lexicon/lock-free-throughput)", "term": "In tension with" }, { "description": "none", "term": "Conflicts with" }, { "description": "[Pessimistic Locking / Deadlock Freedom](/records/tension/deadlock-freedom-pessimistic-locking), [Pessimistic Locking / Latency](/records/tension/latency-pessimistic-locking), [Pessimistic Locking / Lock-Free Throughput](/records/tension/lock-free-throughput-pessimistic-locking)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Blind Overwrite](/records/lexicon/blind-overwrite)", "term": "Violated by" }, { "description": "concurrent update conflicts", "term": "Detected by" }, { "description": "lock wait/deadlock rate", "term": "Measured by" }, { "description": "[Apply Concurrency Control](/records/lexicon/apply-concurrency-control)", "term": "Refactored by" }, { "description": "transactional tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const foo = await fooTable.find(id);\nawait fooTable.save(change(foo));", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "await database.transaction(async tx => {\n const foo = await tx.foos.findForUpdate(id);\n await tx.foos.save(change(foo));\n});", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "transactional tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Lock Ownership](/records/lexicon/lock-ownership), [Isolation](/records/architecture/isolation), [Strong Conflict Prevention](/records/lexicon/strong-conflict-prevention)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-pessimistic-locking", "title": "Pessimistic Locking" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [mandatory](/records/vocabulary/severity-mandatory)", "Scope: function, component, service", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that each piece of mutable state belongs to one unit of concurrent execution, so no two units that run at the same time can write it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation), [Ownership](/records/lexicon/ownership)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Concurrency Correctness](/records/lexicon/concurrency-correctness)", "term": "Reinforces" }, { "description": "[Testability](/records/architecture/testability)", "term": "Enables" }, { "description": "[Data Sharing](/records/lexicon/data-sharing)", "term": "In tension with" }, { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Conflicts with" }, { "description": "[Resource Core](/records/algorithms/resource-core)", "term": "Contracts" }, { "description": "[State Isolation / Data Sharing](/records/tension/data-sharing-state-isolation)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Global Mutable State](/records/lexicon/global-mutable-state)", "term": "Violated by" }, { "description": "static mutable fields, shared caches without ownership", "term": "Detected by" }, { "description": "global state count", "term": "Measured by" }, { "description": "[Encapsulate State](/records/lexicon/encapsulate-state), [Pass Context Explicitly](/records/lexicon/pass-context-explicitly), [Make Immutable](/records/lexicon/make-immutable)", "term": "Refactored by" }, { "description": "lint rules, architecture tests", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "const globalFooState: Foo[] = [];\nfunction addFoo(foo: Foo) { globalFooState.push(foo); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "class FooSession {\n #state: Foo[] = [];\n add(foo: Foo) { this.#state = [...this.#state, foo]; }\n snapshot() { return [...this.#state]; }\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "lint rules, architecture tests", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Ownership](/records/lexicon/ownership), [Predictability](/records/architecture/predictability), [Concurrency Correctness](/records/lexicon/concurrency-correctness), [Testability](/records/architecture/testability)", "term": "Depends on" }, { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-state-isolation", "title": "State Isolation" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [recommended](/records/vocabulary/severity-recommended)", "Scope: function, module, boundary", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A design rule that mutation, I/O and persistence happen at declared boundaries, around a core of pure functions.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Effect Boundaries](/records/lexicon/effect-boundaries)", "term": "Requires" }, { "description": "[Predictability](/records/architecture/predictability), [Testability](/records/architecture/testability)", "term": "Reinforces" }, { "description": "[Pure Core / Imperative Shell](/records/lexicon/pure-core-imperative-shell)", "term": "Enables" }, { "description": "[Performance Optimization](/records/lexicon/performance-optimization)", "term": "In tension with" }, { "description": "[Action at a Distance](/records/architecture/action-at-a-distance), [Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Conflicts with" }, { "description": "[Execution Core](/records/algorithms/execution-core)", "term": "Contracts" }, { "description": "[Controlled Side Effects / Performance Optimization](/records/tension/controlled-side-effects-performance-optimization)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Violated by" }, { "description": "side effects in domain/pure functions", "term": "Detected by" }, { "description": "side-effect boundary violations", "term": "Measured by" }, { "description": "[Make Effects Explicit](/records/lexicon/make-effects-explicit), [Separate Query from Command](/records/lexicon/separate-query-from-command)", "term": "Refactored by" }, { "description": "effect linting, layer rules", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "function calculateFoo(foo: Foo) {\n foo.count += 1;\n fooLog.record(foo);\n fooDb.save(foo);\n return foo.count;\n}", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function nextFoo(foo: Foo): Foo { return { ...foo, count: foo.count + 1 }; }\nasync function applyFoo(foo: Foo, store: FooStore, log: Log) {\n const next = nextFoo(foo);\n log.write(next);\n await store.save(next);\n return next;\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "effect linting, layer rules", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Effect Boundaries](/records/lexicon/effect-boundaries), [Predictability](/records/architecture/predictability), [Testability](/records/architecture/testability), [Pure Core / Imperative Shell](/records/lexicon/pure-core-imperative-shell)", "term": "Depends on" }, { "description": "[Action at a Distance](/records/architecture/action-at-a-distance), [Hidden Side Effect](/records/architecture/hidden-side-effect)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-controlled-side-effects", "title": "Controlled Side Effects" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Transactions / State / Concurrency](/records/architecture-category/transactions-state-concurrency)", "Severity: [contextual](/records/vocabulary/severity-contextual)", "Scope: concurrency, workflow, verification", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of concurrent flow as places holding tokens and transitions that consume and produce them, which can be analyzed for deadlock.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "entries": [ { "description": "[Places and Transitions](/records/lexicon/places-and-transitions)", "term": "Requires" }, { "description": "[Concurrency Correctness](/records/lexicon/concurrency-correctness), [Deadlock Freedom](/records/lexicon/deadlock-freedom)", "term": "Reinforces" }, { "description": "[Concurrent-Flow Modeling](/records/lexicon/concurrent-flow-modeling), [Reachability and Deadlock Analysis](/records/lexicon/reachability-and-deadlock-analysis)", "term": "Enables" }, { "description": "[Modeling Overhead](/records/lexicon/modeling-overhead)", "term": "In tension with" }, { "description": "[Ad-Hoc Lock Ordering](/records/lexicon/ad-hoc-lock-ordering)", "term": "Conflicts with" }, { "description": "[Petri Nets](/records/algorithms/petri-nets)", "term": "Contracts" }, { "description": "[Petri Nets / Modeling Overhead](/records/tension/modeling-overhead-petri-nets)", "term": "Tensions" } ], "kind": "glossary" }, { "entries": [ { "description": "[Ad-Hoc Lock Ordering](/records/lexicon/ad-hoc-lock-ordering)", "term": "Violated by" }, { "description": "deadlocks or lost tokens found only at runtime", "term": "Detected by" }, { "description": "unreachable or deadlock-prone markings", "term": "Measured by" }, { "description": "none", "term": "Refactored by" }, { "description": "concurrency model review", "term": "Enforced by" } ], "kind": "glossary" }, { "code": "acquire(a); acquire(b); work(); release(b); release(a);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const net = petriNet({\n places: { idle: 1, aHeld: 0, bHeld: 0 },\n transitions: [\n { name: \"takeA\", consume: { idle: 1 }, produce: { aHeld: 1 } },\n { name: \"takeB\", consume: { aHeld: 1 }, produce: { bHeld: 1 } },\n ],\n});\nassertNoDeadlock(reachableMarkings(net));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "concurrency model review", "term": "Checked by" }, { "description": "Every multi-step write, shared mutable state and retried side effect", "term": "Population" }, { "description": "A verdict stands until the write path, the isolation level or the concurrency model changes", "term": "Freshness" }, { "description": "The transaction or concurrency test fails a write path that loses an update, commits partially or repeats an effect", "term": "Refusal" }, { "description": "Outcomes of concurrent and retried runs, plus the transaction boundaries read from source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The transaction boundary and the isolation level, which every write path conforms to", "term": "Authoritative side" }, { "description": "[Places and Transitions](/records/lexicon/places-and-transitions), [Concurrency Correctness](/records/lexicon/concurrency-correctness), [Deadlock Freedom](/records/lexicon/deadlock-freedom), [Concurrent-Flow Modeling](/records/lexicon/concurrent-flow-modeling), [Reachability and Deadlock Analysis](/records/lexicon/reachability-and-deadlock-analysis)", "term": "Depends on" }, { "description": "[Ad-Hoc Lock Ordering](/records/lexicon/ad-hoc-lock-ordering)", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "architecture-petri-nets", "title": "Petri Nets" } ], "title": "Transactions / State / Concurrency" } ] }, { "icon": "bi-book", "id": "lexicon", "label": "Lexicon", "layout": "ontology", "sections": [ { "icon": "bi-book", "id": "lexicon-category-application-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that turns an agent's decision into an effect on the world, filed in an actuators folder.", "term": "Definition", "wide": true }, { "description": "actuators/motor.actuator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-actuator-tag", "title": "Actuator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds values available implicitly for the length of one operation, filed in an ambient-context folder.", "term": "Definition", "wide": true }, { "description": "ambient-context/tenant.ambient-context.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ambient-context-tag", "title": "Ambient-Context Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides what an agent does next from what it perceives, filed in a behaviors folder.", "term": "Definition", "wide": true }, { "description": "behaviors/patrol.behavior.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-behavior-tag", "title": "Behavior Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that grants or describes one ability a component may use, filed in a capabilities folder.", "term": "Definition", "wide": true }, { "description": "capabilities/camera.capability.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capability-tag", "title": "Capability Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that assigns an input to one of a set of categories, filed in a classifiers folder.", "term": "Definition", "wide": true }, { "description": "classifiers/spam.classifier.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-classifier-tag", "title": "Classifier Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries the ambient values a unit of work reads without passing them through every call, filed in a context folder.", "term": "Definition", "wide": true }, { "description": "context/request.context.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-tag", "title": "Context Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that receives an external request and routes it to the code that answers it, filed in a controllers folder.", "term": "Definition", "wide": true }, { "description": "controllers/account.controller.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controller-tag", "title": "Controller Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that owns a lifecycle and drives the collaborators it depends on, filed in a coordinators folder.", "term": "Definition", "wide": true }, { "description": "coordinators/upload.coordinator.ts", "term": "Example" }, { "description": "[Service Tag](/records/lexicon/service-tag): A coordinator owns a lifecycle and drives its collaborators, while a service offers a stateful capability that others call.", "term": "Distinct from" }, { "description": "[Processor Tag](/records/lexicon/processor-tag): A coordinator drives collaborators through a lifecycle, while a processor applies one operation to each item passing through.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Coordinator](/records/lexicon/coordinator)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordinator-tag", "title": "Coordinator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that assigns and reads the identifiers tying related operations together, filed in a correlation folder.", "term": "Definition", "wide": true }, { "description": "correlation/request.correlation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-correlation-tag", "title": "Correlation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that selects which handler receives each incoming message, filed in a dispatchers folder.", "term": "Definition", "wide": true }, { "description": "dispatchers/command.dispatcher.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dispatcher-tag", "title": "Dispatcher Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that produces events or output for others to receive, filed in an emitters folder.", "term": "Definition", "wide": true }, { "description": "emitters/particle.emitter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-emitter-tag", "title": "Emitter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that recognizes a pattern of pointer or touch movement as one intent, filed in a gestures folder.", "term": "Definition", "wide": true }, { "description": "gestures/pinch.gesture.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-gesture-tag", "title": "Gesture Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that scores options by an approximate rule where an exact answer costs too much, filed in a heuristics folder.", "term": "Definition", "wide": true }, { "description": "heuristics/path-cost.heuristic.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-heuristic-tag", "title": "Heuristic Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that reads device input and turns it into actions the system understands, filed in an input folder.", "term": "Definition", "wide": true }, { "description": "input/gamepad.input.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-input-tag", "title": "Input Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that represents what an agent means to do before any action carries it out, filed in an intents folder.", "term": "Definition", "wide": true }, { "description": "intents/attack.intent.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-intent-tag", "title": "Intent Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a unit of work run outside the request that asked for it, filed in a jobs folder.", "term": "Definition", "wide": true }, { "description": "jobs/invoice-export.job.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-job-tag", "title": "Job Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that adjusts an agent's parameters from the outcomes it observes, filed in a learners folder.", "term": "Definition", "wide": true }, { "description": "learners/reward.learner.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-learner-tag", "title": "Learner Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that is registered for one kind of event and runs when it arrives, filed in a listeners folder.", "term": "Definition", "wide": true }, { "description": "listeners/keyboard.listener.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-listener-tag", "title": "Listener Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file through which peers communicate so that none of them refers to another directly, filed in a mediators folder.", "term": "Definition", "wide": true }, { "description": "mediators/chat.mediator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mediator-tag", "title": "Mediator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one permitted change to held state, filed in a mutations folder.", "term": "Definition", "wide": true }, { "description": "mutations/rename-file.mutation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mutation-tag", "title": "Mutation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines how a participant moves between views, filed in a navigation folder.", "term": "Definition", "wide": true }, { "description": "navigation/tab-bar.navigation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-navigation-tag", "title": "Navigation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that watches a subject and reacts when it changes, filed in an observers folder.", "term": "Definition", "wide": true }, { "description": "observers/stock-price.observer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-observer-tag", "title": "Observer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that sequences several independent steps into one run and decides what happens when one fails, filed in an orchestrators folder.", "term": "Definition", "wide": true }, { "description": "orchestrators/onboarding.orchestrator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-orchestrator-tag", "title": "Orchestrator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that formats data for a passive view and handles that view's input, filed in a presenters folder.", "term": "Definition", "wide": true }, { "description": "presenters/invoice.presenter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-presenter-tag", "title": "Presenter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries context across a boundary such as a thread or a network call, filed in a propagation folder.", "term": "Definition", "wide": true }, { "description": "propagation/trace.propagation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-propagation-tag", "title": "Propagation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that sends messages to a topic without knowing who receives them, filed in a publishers folder.", "term": "Definition", "wide": true }, { "description": "publishers/order.publisher.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Publisher](/records/lexicon/publisher)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-publisher-tag", "title": "Publisher Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes the next state from the current state and an action, filed in a reducers folder.", "term": "Definition", "wide": true }, { "description": "reducers/todo.reducer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reducer-tag", "title": "Reducer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that derives a value from held state for its readers, filed in a selectors folder.", "term": "Definition", "wide": true }, { "description": "selectors/visible-todos.selector.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-selector-tag", "title": "Selector Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that offers a stateful capability other code calls, filed in a services folder.", "term": "Definition", "wide": true }, { "description": "services/billing.service.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-service-tag", "title": "Service Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a reactive value whose readers update when it changes, filed in a signals folder.", "term": "Definition", "wide": true }, { "description": "signals/counter.signal.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-signal-tag", "title": "Signal Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one ordered phase of a larger run, filed in a stages folder.", "term": "Definition", "wide": true }, { "description": "stages/transcode.stage.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Stages](/records/lexicon/stages)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stage-tag", "title": "Stage Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds the current condition of something the system tracks, filed in a state folder.", "term": "Definition", "wide": true }, { "description": "state/player.state.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-tag", "title": "State Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a set of states and the allowed transitions between them, filed in a state-machines folder.", "term": "Definition", "wide": true }, { "description": "state-machines/order.state-machine.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-machine-tag", "title": "State-Machine Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that performs one advance of a process, filed in a steps folder.", "term": "Definition", "wide": true }, { "description": "steps/payment-capture.step.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-step-tag", "title": "Step Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds state and controls how it is read and changed, filed in a stores folder.", "term": "Definition", "wide": true }, { "description": "stores/cart.store.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-store-tag", "title": "Store Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that receives the messages of a topic it has joined, filed in a subscribers folder.", "term": "Definition", "wide": true }, { "description": "subscribers/email.subscriber.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Subscriber](/records/lexicon/subscriber)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subscriber-tag", "title": "Subscriber Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the binding between a subscriber and what it receives, including how it ends, filed in a subscriptions folder.", "term": "Definition", "wide": true }, { "description": "subscriptions/newsletter.subscription.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subscription-tag", "title": "Subscription Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one named piece of work a runner can schedule and report on, filed in a tasks folder.", "term": "Definition", "wide": true }, { "description": "tasks/nightly-cleanup.task.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-task-tag", "title": "Task Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one move from a state to the next with its guard, filed in a transitions folder.", "term": "Definition", "wide": true }, { "description": "transitions/door-open.transition.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transition-tag", "title": "Transition Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that shapes state for one view and exposes the actions that view offers, filed in a viewmodels folder.", "term": "Definition", "wide": true }, { "description": "viewmodels/profile.viewmodel.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-viewmodel-tag", "title": "Viewmodel Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Application Concerns](/records/lexicon-category/application-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a multi-step process with its transitions and outcomes, filed in a workflows folder.", "term": "Definition", "wide": true }, { "description": "workflows/approval.workflow.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-workflow-tag", "title": "Workflow Tag" } ], "title": "Application Concerns" }, { "icon": "bi-book", "id": "lexicon-category-architecture-review-evolution-governance", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording a decision to accept a risk with who accepted it and when it is reviewed again.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-accepted-risk-record", "title": "Accepted Risk Record" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Designing by improvisation with no deliberate structure or review, so the architecture accretes inconsistently.", "term": "Definition", "wide": true }, { "description": "[Design Review](/records/architecture/design-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design Review](/records/architecture/design-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-design", "title": "Ad-Hoc Design" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Combining unrelated design patterns arbitrarily with no coherent rationale, producing an inconsistent structure.", "term": "Definition", "wide": true }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-pattern-mixing", "title": "Ad-Hoc Pattern Mixing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which analyzing the impact of every change before making it adds effort and slows delivery.", "term": "Definition", "wide": true }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with impact-analysis", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-analysis-overhead", "title": "Analysis Overhead" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for justifying each component by a concrete use case it serves.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anchor-to-use-cases", "title": "Anchor to Use Cases" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit criteria define what a review judges an architecture against.", "term": "Definition", "wide": true }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-criteria", "title": "Architecture Criteria" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Gradual divergence of an implementation from its intended architecture as unreviewed changes accumulate.", "term": "Definition", "wide": true }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture), [Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-drift", "title": "Architecture Drift" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system rests on a sound, deliberately designed architectural base rather than accreted structure.", "term": "Definition", "wide": true }, { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-foundation", "title": "Architecture Foundation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit, checkable rules govern how the architecture may be structured and evolved.", "term": "Definition", "wide": true }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-rules", "title": "Architecture Rules" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for expressing a structural rule, such as a dependency direction, as a test that runs in the build.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud), [Boundary Leakage](/records/architecture/boundary-leakage), [Manual-Only Governance](/records/architecture/manual-only-governance), [Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-test", "title": "Architecture Test" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping removed code reachable in history or an archive instead of in the live tree.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zombie Code](/records/architecture/zombie-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-archive-reference", "title": "Archive Reference" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording a named owner for each module, risk or rule, who decides on its changes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud), [Shared Mutable State](/records/architecture/shared-mutable-state), [Unowned Risk](/records/architecture/unowned-risk), [Lava Flow](/records/architecture/lava-flow), [Decentralization](/records/architecture/decentralization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assign-owner", "title": "Assign Owner" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Judging an architecture from untested assumptions instead of measured evidence, yielding unreliable conclusions.", "term": "Definition", "wide": true }, { "description": "[Assessment](/records/architecture/assessment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Assessment](/records/architecture/assessment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assumption-based-judgment", "title": "Assumption-Based Judgment" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A concrete scenario specifying how a quality attribute should hold under defined conditions and stimuli.", "term": "Definition", "wide": true }, { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-attribute-scenarios", "title": "Attribute Scenarios" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to verify conformance to architectural rules automatically rather than by manual review.", "term": "Definition", "wide": true }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-architecture-compliance", "title": "Automated Architecture Compliance" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Changing a system without analyzing what the change affects, so unintended consequences go unseen.", "term": "Definition", "wide": true }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blind-change", "title": "Blind Change" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a change can be made with confidence that its effects are understood and contained.", "term": "Definition", "wide": true }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-change-safety", "title": "Change Safety" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to define clear component boundaries from the outset, free of legacy entanglement.", "term": "Definition", "wide": true }, { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-clean-boundary-design", "title": "Clean Boundary Design" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which improving one quality attribute forces a trade-off against another.", "term": "Definition", "wide": true }, { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with quality-attributes", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-competing-attributes", "title": "Competing Attributes" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A recorded account of the trade-offs and downstream effects that follow from an architectural decision.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consequences", "title": "Consequences" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for choosing a pattern by the forces of the problem at hand instead of by familiarity.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Golden Hammer](/records/architecture/golden-hammer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contextual-pattern-selection", "title": "Contextual Pattern Selection" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Iteratively refining a system's design in small, ongoing steps rather than in large infrequent overhauls.", "term": "Definition", "wide": true }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuous-improvement", "title": "Continuous Improvement" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let an architecture change over time within deliberate guardrails rather than drifting freely.", "term": "Definition", "wide": true }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-architecture-evolution", "title": "Controlled Architecture Evolution" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit, agreed measures define how an assessment reaches its verdict.", "term": "Definition", "wide": true }, { "description": "[Assessment](/records/architecture/assessment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Assessment](/records/architecture/assessment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-criteria", "title": "Criteria" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of how a system is presently structured and behaves, used as the baseline for analysis.", "term": "Definition", "wide": true }, { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-current-state", "title": "Current State" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for failing the build on exports and branches that nothing reaches.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zombie Code](/records/architecture/zombie-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dead-code-check", "title": "Dead Code Check" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A recorded architectural choice capturing what was chosen and the context in which it was made.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Referenced by" }, { "description": "[Consequences](/records/lexicon/consequences): The decision records what was chosen, while the consequences record what follows from choosing it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decision", "title": "Decision" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to trace why past architectural choices were made by consulting their recorded rationale.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decision-history", "title": "Decision History" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording a decision together with the options rejected and the forces that decided it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Golden Hammer](/records/architecture/golden-hammer), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Greenfield Development](/records/architecture/greenfield-development)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decision-record-with-alternatives", "title": "Decision Record with Alternatives" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for re-examining recorded decisions when the evidence behind them changes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big-Upfront Frozen Architecture](/records/architecture/big-upfront-frozen-architecture), [First-Principles Design](/records/architecture/first-principles-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decision-review", "title": "Decision Review" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to find defects in a change before it is merged or shipped.", "term": "Definition", "wide": true }, { "description": "[Code Review](/records/architecture/code-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code Review](/records/architecture/code-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-defect-detection", "title": "Defect Detection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping concrete code until a second real variation shows what the abstraction must cover.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Speculative Generality](/records/architecture/speculative-generality), [Premature Abstraction](/records/architecture/premature-abstraction), [Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-defer-generalization", "title": "Defer Generalization" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing code once measurement shows nothing calls it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lava Flow](/records/architecture/lava-flow), [Zombie Code](/records/architecture/zombie-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delete-after-evidence", "title": "Delete After Evidence" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording for each obsolete path its owner, its replacement and its removal date.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lava Flow](/records/architecture/lava-flow)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deprecation-plan", "title": "Deprecation Plan" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit criteria define what a design review evaluates a proposal against.", "term": "Definition", "wide": true }, { "description": "[Design Review](/records/architecture/design-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design Review](/records/architecture/design-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-design-criteria", "title": "Design Criteria" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Pushing changes straight to the main branch with no review, so unvetted code lands directly in production.", "term": "Definition", "wide": true }, { "description": "[Code Review](/records/architecture/code-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code Review](/records/architecture/code-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-to-main-unreviewed-change", "title": "Direct-to-main Unreviewed Change" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which keeping decision records current adds ongoing upkeep effort.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with architecture-decision-records", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-documentation-maintenance", "title": "Documentation Maintenance" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for tolerating a small duplication until enough cases exist to show the shared shape.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Premature Abstraction](/records/architecture/premature-abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicate-until-the-pattern-stabilizes", "title": "Duplicate Until the Pattern Stabilizes" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to catch design flaws during review before they are built into the system.", "term": "Definition", "wide": true }, { "description": "[Design Review](/records/architecture/design-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design Review](/records/architecture/design-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-early-defect-prevention", "title": "Early Defect Prevention" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to ship a minimal architecture quickly while keeping essential safeguards in place.", "term": "Definition", "wide": true }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-early-delivery-with-guardrails", "title": "Early Delivery with Guardrails" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to restructure code more safely because consistent patterns make change predictable.", "term": "Definition", "wide": true }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-easier-refactoring", "title": "Easier Refactoring" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the few quality attributes critical to viability be satisfied before any others.", "term": "Definition", "wide": true }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-essential-quality-attributes", "title": "Essential Quality Attributes" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to shape an architecture to the problem it solves rather than to convention.", "term": "Definition", "wide": true }, { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fit-for-purpose-architecture", "title": "Fit-for-Purpose Architecture" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for listing the pressures a design must balance before choosing a pattern for it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Golden Hammer](/records/architecture/golden-hammer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-force-analysis", "title": "Force Analysis" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a design can grow to meet higher future demand without rework.", "term": "Definition", "wide": true }, { "description": "[Minimum Viable Architecture](/records/architecture/minimum-viable-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with minimum-viable-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-future-scalability", "title": "Future Scalability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which evolving an architecture continuously demands sustained governance to prevent uncontrolled drift.", "term": "Definition", "wide": true }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with evolutionary-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-governance-discipline", "title": "Governance Discipline" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which parts of one project use different structures, formats, tools or patterns for the same kind of thing.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standardization](/records/architecture/standardization), [Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inconsistent-conventions", "title": "Inconsistent Conventions" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a system evolve in small, reversible increments rather than large risky leaps.", "term": "Definition", "wide": true }, { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incremental-change", "title": "Incremental Change" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing standards constrains teams' freedom to innovate independently.", "term": "Definition", "wide": true }, { "description": "[Standardization](/records/architecture/standardization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with standardization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-innovation-autonomy", "title": "Innovation/Autonomy" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A binding limitation imposed by pre-existing legacy systems that a new design must accommodate.", "term": "Definition", "wide": true }, { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with greenfield-development", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-legacy-constraints", "title": "Legacy Constraints" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing architectural consistency limits individual teams' freedom to make local choices.", "term": "Definition", "wide": true }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with architectural-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-autonomy", "title": "Local Autonomy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing shared patterns sacrifices locally optimal one-off solutions.", "term": "Definition", "wide": true }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pattern-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-optimization", "title": "Local Optimization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Relying solely on human review to police architecture, with no automated checks, so violations slip through.", "term": "Definition", "wide": true }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manual-architecture-review-only", "title": "Manual Architecture Review Only" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an architectural rule be expressed as an objective, automatically checkable measure.", "term": "Definition", "wide": true }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-measurable-architecture-rule", "title": "Measurable Architecture Rule" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for measuring the time and effort an abstraction adds to delivering a change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-measure-delivery-cost", "title": "Measure Delivery Cost" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording the actions that reduce a risk, with an owner and a date for each.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unowned Risk](/records/architecture/unowned-risk), [Gap Analysis](/records/architecture/gap-analysis), [Threat Modeling](/records/architecture/threat-modeling), [Risk Management](/records/architecture/risk-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mitigation-plan", "title": "Mitigation Plan" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A convention of naming and structuring code uniformly across a codebase so its shape is predictable.", "term": "Definition", "wide": true }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pattern Consistency](/records/architecture/pattern-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-naming-structure-conventions", "title": "Naming/Structure Conventions" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system is easy to run, monitor, and keep healthy in production.", "term": "Definition", "wide": true }, { "description": "[Standardization](/records/architecture/standardization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standardization](/records/architecture/standardization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operability", "title": "Operability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change a system with confidence that consistent structure keeps outcomes foreseeable.", "term": "Definition", "wide": true }, { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architectural Consistency](/records/architecture/architectural-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-predictable-evolution", "title": "Predictable Evolution" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to rank refactoring work by assessed impact so effort targets the highest-value fixes.", "term": "Definition", "wide": true }, { "description": "[Assessment](/records/architecture/assessment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Assessment](/records/architecture/assessment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prioritized-refactoring", "title": "Prioritized Refactoring" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Breaking a problem into fundamental sub-problems that can be reasoned about independently.", "term": "Definition", "wide": true }, { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-problem-decomposition", "title": "Problem Decomposition" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system meets its functional and non-functional expectations.", "term": "Definition", "wide": true }, { "description": "[Code Review](/records/architecture/code-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code Review](/records/architecture/code-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quality", "title": "Quality" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that target levels for key quality attributes be defined for an architecture to meet.", "term": "Definition", "wide": true }, { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quality-goals", "title": "Quality Goals" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stating each quality attribute as a stimulus, a response and a measure the design must meet.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature-Only Design](/records/architecture/feature-only-design), [Quality Attributes](/records/architecture/quality-attributes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quality-scenarios", "title": "Quality Scenarios" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to select exactly which tests a change requires by analyzing what it affects.", "term": "Definition", "wide": true }, { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Impact Analysis](/records/architecture/impact-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-regression-scope-selection", "title": "Regression Scope Selection" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to plan the steps that close the gap between a system's current and target states.", "term": "Definition", "wide": true }, { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remediation-planning", "title": "Remediation Planning" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deleting the structure of a pattern whose forces are absent, leaving the plain code it wrapped.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pattern Cargo Cult](/records/architecture/pattern-cargo-cult), [First-Principles Design](/records/architecture/first-principles-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remove-pattern-shell", "title": "Remove Pattern Shell" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A body of proven architectural guidance packaged for reuse across projects.", "term": "Definition", "wide": true }, { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reusable-architecture-guidance", "title": "Reusable Architecture Guidance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which designing from first principles forgoes the leverage of reusing proven patterns.", "term": "Definition", "wide": true }, { "description": "[First-Principles Design](/records/architecture/first-principles-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with first-principles-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reuse-of-established-patterns", "title": "Reuse of Established Patterns" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that agreed standards define what a code review checks for.", "term": "Definition", "wide": true }, { "description": "[Code Review](/records/architecture/code-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code Review](/records/architecture/code-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-review-standards", "title": "Review Standards" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to surface architectural risks early by reviewing structure before it is built.", "term": "Definition", "wide": true }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-risk-detection", "title": "Risk Detection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping every known risk in one list with its owner, severity, mitigation and review date.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature-Only Design](/records/architecture/feature-only-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-risk-register", "title": "Risk Register" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which keeping fitness-function rules current adds ongoing upkeep effort.", "term": "Definition", "wide": true }, { "description": "[Fitness Functions](/records/architecture/fitness-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with fitness-functions", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rule-maintenance", "title": "Rule Maintenance" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for setting a date on which a decision, risk or exception is examined again.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scheduled-review", "title": "Scheduled Review" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for ranking each finding or risk on a declared scale that sets how soon it is handled.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unowned Risk](/records/architecture/unowned-risk)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-severity-classification", "title": "Severity Classification" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A canonical, widely agreed reusable solution that a reference architecture prescribes for a recurring problem.", "term": "Definition", "wide": true }, { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-standard-patterns", "title": "Standard Patterns" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A defined, authoritative set of standards that units are expected to conform to.", "term": "Definition", "wide": true }, { "description": "[Standardization](/records/architecture/standardization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standardization](/records/architecture/standardization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-standards-definition", "title": "Standards Definition" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the desired future structure a system is being steered toward.", "term": "Definition", "wide": true }, { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Referenced by" }, { "description": "[Current State](/records/lexicon/current-state): The target state is where the system is steered, while the current state is the baseline it starts from.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-target-state", "title": "Target State" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for counting violations of each architecture rule over time, so recurrence is visible.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance), [Static Analysis](/records/architecture/static-analysis), [Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-track-rule-metrics", "title": "Track Rule Metrics" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The ability to weigh competing quality attributes and choose a balanced compromise between them.", "term": "Definition", "wide": true }, { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Quality Attributes](/records/architecture/quality-attributes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trade-off-analysis", "title": "Trade-Off Analysis" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for scoring candidate designs against the quality attributes that matter for the decision.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Golden Hammer](/records/architecture/golden-hammer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trade-off-matrix", "title": "Trade-Off Matrix" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Critical architectural knowledge held only in the developers' heads and never recorded, lost when they leave.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tribal-knowledge", "title": "Tribal Knowledge" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Allowing unlimited variation in how the same problem is solved, so the system sprawls into inconsistent one-offs.", "term": "Definition", "wide": true }, { "description": "[Standardization](/records/architecture/standardization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standardization](/records/architecture/standardization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-variation", "title": "Unbounded Variation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Teams independently diverging from a shared reference architecture, fragmenting the system into incompatible variants.", "term": "Definition", "wide": true }, { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reference Architecture](/records/architecture/reference-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uncoordinated-divergence", "title": "Uncoordinated Divergence" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Attempting to close a gap toward a goal that was never clearly defined, so progress cannot be judged.", "term": "Definition", "wide": true }, { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Gap Analysis](/records/architecture/gap-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-undefined-target", "title": "Undefined Target" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which starting on a clean slate forces early decisions while requirements are still unknown.", "term": "Definition", "wide": true }, { "description": "[Greenfield Development](/records/architecture/greenfield-development)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with greenfield-development", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unknown-requirements", "title": "Unknown Requirements" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "Merging changes to architectural structure without review, letting unvetted design decisions into the system.", "term": "Definition", "wide": true }, { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Review](/records/architecture/architecture-review)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unreviewed-structural-change", "title": "Unreviewed Structural Change" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking that a pattern in use has the boundary rules and contracts the pattern requires.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pattern Cargo Cult](/records/architecture/pattern-cargo-cult)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-validate-required-forces", "title": "Validate Required Forces" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Architecture Review Evolution Governance](/records/lexicon-category/architecture-review-evolution-governance)", "Layer: [Evolution Principles](/records/layer/evolution-principles)" ], "kind": "list" }, { "entries": [ { "description": "A technique for proving a design by building one end-to-end path through every layer before generalizing it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Astronaut](/records/architecture/architecture-astronaut)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vertical-slice-proof", "title": "Vertical Slice Proof" } ], "title": "Architecture Review Evolution Governance" }, { "icon": "bi-book", "id": "lexicon-category-behavioral-patterns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to concentrate how a set of objects interact within one mediating component.", "term": "Definition", "wide": true }, { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-interaction-logic", "title": "Centralized Interaction Logic" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which extracting each algorithm into its own class raises the total number of classes.", "term": "Definition", "wide": true }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with strategy-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-class-count", "title": "Class Count" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which modeling each state as its own class multiplies the number of classes.", "term": "Definition", "wide": true }, { "description": "[State Pattern](/records/architecture/state-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with state-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-class-proliferation", "title": "Class Proliferation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let subclasses vary only the designated steps of a fixed algorithm.", "term": "Definition", "wide": true }, { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-variation", "title": "Controlled Variation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of complexity in how objects must coordinate, which motivates a mediator.", "term": "Definition", "wide": true }, { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordination-complexity", "title": "Coordination Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to notify interested parties of a change without the source knowing who they are.", "term": "Definition", "wide": true }, { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decoupled-notification", "title": "Decoupled Notification" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to capture a request as an object so it can be run later, held in a queue, or logged.", "term": "Definition", "wide": true }, { "description": "Request Queuing", "term": "Aliases" }, { "description": "[Command Pattern](/records/architecture/command-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Pattern](/records/architecture/command-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-execution", "title": "Deferred Execution" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Wiring a source to notify specific recipients by direct call, coupling it to each one.", "term": "Definition", "wide": true }, { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-callback-coupling", "title": "Direct Callback Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Invoking an operation by direct method call, so it cannot be queued, logged, or undone.", "term": "Definition", "wide": true }, { "description": "[Command Pattern](/records/architecture/command-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Pattern](/records/architecture/command-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-method-invocation", "title": "Direct Method Invocation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Repeating the same overall algorithm in many places, each copy re-implementing the shared steps.", "term": "Definition", "wide": true }, { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicated-workflow", "title": "Duplicated Workflow" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which adding new operations stays easy only while the set of element types stays fixed.", "term": "Definition", "wide": true }, { "description": "[Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with visitor-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-element-stability", "title": "Element Stability" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring the states and legal transitions of a lifecycle, so an operation called in the wrong state is refused.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-encode-state-machine", "title": "Encode State Machine" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to enumerate and reason about every state a system can occupy and every transition between them.", "term": "Definition", "wide": true }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exhaustive-state-reasoning", "title": "Exhaustive State Reasoning" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an object's states and their transitions be modeled explicitly.", "term": "Definition", "wide": true }, { "description": "[State Pattern](/records/architecture/state-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[State Pattern](/records/architecture/state-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-state-model", "title": "Explicit State Model" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the complete set of possible states be defined up front.", "term": "Definition", "wide": true }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-state-set", "title": "Explicit State Set" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Forcing clients to traverse a collection through its internal structure, coupling them to that structure.", "term": "Definition", "wide": true }, { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exposed-internal-representation", "title": "Exposed Internal Representation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Reading or writing an object's internal state from outside to snapshot it, breaking its encapsulation.", "term": "Definition", "wide": true }, { "description": "[Memento Pattern](/records/architecture/memento-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Memento Pattern](/records/architecture/memento-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-external-state-reach-in", "title": "External State Reach-In" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Defaulting to safe, benign behavior when a value or handler is absent rather than failing or branching.", "term": "Definition", "wide": true }, { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fail-safe-defaults", "title": "Fail-Safe Defaults" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Enumerating every combination of conditions as a separate flat state, so the state count explodes.", "term": "Definition", "wide": true }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flat-state-explosion", "title": "Flat State Explosion" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reuse a fixed algorithm skeleton across many concrete implementations.", "term": "Definition", "wide": true }, { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-framework-reuse", "title": "Framework Reuse" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to permit a state transition only when a specified condition holds.", "term": "Definition", "wide": true }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guarded-transitions", "title": "Guarded Transitions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to nest states so shared behavior is defined once on an enclosing state.", "term": "Definition", "wide": true }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Referenced by" }, { "description": "[Guarded Transitions](/records/lexicon/guarded-transitions): Hierarchical states nest states to share behavior, while guarded transitions condition a move between states.", "term": "Distinct from" }, { "description": "[Parallel Regions](/records/lexicon/parallel-regions): Hierarchical states nest one state inside another, while parallel regions run independent states at the same time.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hierarchical-states", "title": "Hierarchical States" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which basing a template method on subclassing binds subclasses tightly to the base class.", "term": "Definition", "wide": true }, { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with template-method-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inheritance-coupling", "title": "Inheritance Coupling" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that competing algorithms share one interface so they can be swapped freely.", "term": "Definition", "wide": true }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interchangeable-algorithms", "title": "Interchangeable Algorithms" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Selecting behavior with a large branching conditional instead of pluggable strategy objects.", "term": "Definition", "wide": true }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-large-conditional-logic", "title": "Large Conditional Logic" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to produce a collection's elements one at a time on demand rather than all at once.", "term": "Definition", "wide": true }, { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lazy-traversal", "title": "Lazy Traversal" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for expressing a required call order in types or a state machine instead of in documentation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Temporal Coupling](/records/architecture/temporal-coupling), [Causality](/records/architecture/causality), [Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-make-order-explicit", "title": "Make Order Explicit" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which concentrating interaction logic in a mediator risks growing it into an overloaded object.", "term": "Definition", "wide": true }, { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with mediator-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mediator-god-object", "title": "Mediator God Object" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of memory consumed by retaining state snapshots for later restoration.", "term": "Definition", "wide": true }, { "description": "[Memento Pattern](/records/architecture/memento-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with memento-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-memory-footprint", "title": "Memory Footprint" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting every object refer directly to every other, forming a dense mesh of point-to-point dependencies.", "term": "Definition", "wide": true }, { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mediator Pattern](/records/architecture/mediator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mesh-dependencies", "title": "Mesh Dependencies" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Handling every case in one large handler instead of a chain of focused, single-purpose handlers.", "term": "Definition", "wide": true }, { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-monolithic-handler", "title": "Monolithic Handler" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to remove scattered null checks by substituting a benign do-nothing object.", "term": "Definition", "wide": true }, { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-null-check-elimination", "title": "Null-Check Elimination" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add new operations over a structure without modifying its element classes.", "term": "Definition", "wide": true }, { "description": "[Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operation-extension-without-element-change", "title": "Operation Extension Without Element Change" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to offer a request to handlers in sequence until one of them accepts it.", "term": "Definition", "wide": true }, { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordered-fallthrough", "title": "Ordered Fallthrough" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to model concurrently-active, independent regions of state within one machine.", "term": "Definition", "wide": true }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Referenced by" }, { "description": "[Guarded Transitions](/records/lexicon/guarded-transitions): Parallel regions are independent states active at once, while guarded transitions condition one move between states.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-regions", "title": "Parallel Regions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add or reorder request handlers without changing the ones already in the chain.", "term": "Definition", "wide": true }, { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Referenced by" }, { "description": "[Ordered Fallthrough](/records/lexicon/ordered-fallthrough): Pluggable handling adds or reorders handlers without changing the others, while ordered fallthrough offers a request to each handler in turn until one accepts.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pluggable-handling", "title": "Pluggable Handling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to choose among interchangeable algorithms at runtime.", "term": "Definition", "wide": true }, { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Strategy Pattern](/records/architecture/strategy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-behavior-selection", "title": "Runtime Behavior Selection" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which every call site repeats a null check before the same operation.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scattered-null-guards", "title": "Scattered Null Guards" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the real object and its null stand-in implement one common interface.", "term": "Definition", "wide": true }, { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-behavioral-interface", "title": "Shared Behavioral Interface" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a do-nothing stand-in can hide an error.", "term": "Definition", "wide": true }, { "description": "[Null Object Pattern](/records/architecture/null-object-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with null-object-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-silent-no-op-risk", "title": "Silent No-Op Risk" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to capture an object's state and later restore it to that captured point.", "term": "Definition", "wide": true }, { "description": "[Memento Pattern](/records/architecture/memento-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Memento Pattern](/records/architecture/memento-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-snapshot-restore", "title": "Snapshot/Restore" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the overall algorithm's structure stay fixed while specific steps vary.", "term": "Definition", "wide": true }, { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Template Method Pattern](/records/architecture/template-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-algorithm-skeleton", "title": "Stable Algorithm Skeleton" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the set of element types stay fixed so new operations can be added over them.", "term": "Definition", "wide": true }, { "description": "[Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-element-hierarchy", "title": "Stable Element Hierarchy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the number of explicit states grows unmanageably as conditions multiply.", "term": "Definition", "wide": true }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with finite-state-machine", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-explosion", "title": "State Explosion" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to attach behavior to each state so an object acts according to its current state.", "term": "Definition", "wide": true }, { "description": "[State Pattern](/records/architecture/state-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[State Pattern](/records/architecture/state-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-local-behavior", "title": "State-Local Behavior" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to traverse a collection without depending on how it is internally organized.", "term": "Definition", "wide": true }, { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Referenced by" }, { "description": "[Lazy Traversal](/records/lexicon/lazy-traversal): Structure-agnostic iteration hides how a collection is organized, while lazy traversal produces its elements only on demand.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structure-agnostic-iteration", "title": "Structure-Agnostic Iteration" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement of an agreed interface by which subjects notify and subscribers receive updates.", "term": "Definition", "wide": true }, { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observer Pattern](/records/architecture/observer-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subject-subscriber-contract", "title": "Subject/Subscriber Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that every handler in a chain share one interface so requests pass along uniformly.", "term": "Definition", "wide": true }, { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chain of Responsibility Pattern](/records/architecture/chain-of-responsibility-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uniform-handler-interface", "title": "Uniform Handler Interface" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Behavioral Patterns](/records/lexicon-category/behavioral-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that collections expose one common interface for stepping through their elements.", "term": "Definition", "wide": true }, { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Iterator Pattern](/records/architecture/iterator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uniform-traversal-interface", "title": "Uniform Traversal Interface" } ], "title": "Behavioral Patterns" }, { "icon": "bi-book", "id": "lexicon-category-causality-ordering-distributed-time", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Reordering causally related operations freely, so effects can appear before their causes.", "term": "Definition", "wide": true }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" }, { "description": "[Read-Your-Writes Violation](/records/architecture/read-your-writes-violation): Arbitrary reordering lets any effect appear before its cause, while a read-your-writes violation is one writer reading back a stale copy of its own write.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-arbitrary-reordering", "title": "Arbitrary Reordering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming a distributed system can be fully consistent and available at once, ignoring partitions that force a choice.", "term": "Definition", "wide": true }, { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assumed-total-consistency-and-availability", "title": "Assumed Total Consistency And Availability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which forbidding cycles prevents two components from depending on each other bidirectionally.", "term": "Definition", "wide": true }, { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with directed-acyclic-graph", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bidirectional-collaboration", "title": "Bidirectional Collaboration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to derive a correct build or execution order from a graph that contains no cycles.", "term": "Definition", "wide": true }, { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-build-order", "title": "Build Order" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that operations be applied in an order consistent with their cause-and-effect relationships.", "term": "Definition", "wide": true }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-causal-ordering", "title": "Causal Ordering" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Reasoning about which events must precede others based on their causal relationships.", "term": "Definition", "wide": true }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-causal-reasoning", "title": "Causal Reasoning" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Recording which event caused which, so cause-and-effect chains can be reconstructed later.", "term": "Definition", "wide": true }, { "description": "[Causality](/records/architecture/causality)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causality](/records/architecture/causality)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-causation-tracking", "title": "Causation Tracking" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which physical clocks on different nodes drift apart, distorting time-based ordering.", "term": "Definition", "wide": true }, { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with hybrid-logical-clocks", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-clock-skew", "title": "Clock Skew" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that concurrent updates merge in any order to the same result.", "term": "Definition", "wide": true }, { "description": "[CRDTs](/records/architecture/crdts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CRDTs](/records/architecture/crdts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-commutative-merge", "title": "Commutative Merge" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect when two updates happened concurrently rather than one causally after the other.", "term": "Definition", "wide": true }, { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concurrent-update-detection", "title": "Concurrent Update Detection" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for replicas to converge to one state automatically without conflict resolution.", "term": "Definition", "wide": true }, { "description": "[CRDTs](/records/architecture/crdts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CRDTs](/records/architecture/crdts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-conflict-free-replica-convergence", "title": "Conflict-Free Replica Convergence" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming consistency carries no cost while the network is healthy, ignoring the latency it still imposes.", "term": "Definition", "wide": true }, { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-assumed-free-when-healthy", "title": "Consistency Assumed Free When Healthy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process a stream statefully with correct results by handling events in their proper order.", "term": "Definition", "wide": true }, { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-correct-stateful-processing", "title": "Correct Stateful Processing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reason correctly about a workflow's steps by knowing their causal relationships.", "term": "Definition", "wide": true }, { "description": "[Causality](/records/architecture/causality)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causality](/records/architecture/causality)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-correct-workflow-reasoning", "title": "Correct Workflow Reasoning" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect cycles in a dependency graph before they cause deadlock or infinite resolution.", "term": "Definition", "wide": true }, { "description": "[Dependency Graph](/records/architecture/dependency-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dependency Graph](/records/architecture/dependency-graph)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cycle-detection", "title": "Cycle Detection" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each operation declare the operations it causally depends on.", "term": "Definition", "wide": true }, { "description": "[Causal Dependency](/records/architecture/causal-dependency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Dependency](/records/architecture/causal-dependency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dependency-declaration", "title": "Dependency Declaration" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that dependencies between units be discovered and represented explicitly as a graph.", "term": "Definition", "wide": true }, { "description": "[Dependency Graph](/records/architecture/dependency-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dependency Graph](/records/architecture/dependency-graph)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dependency-extraction", "title": "Dependency Extraction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which resolving dependencies dynamically at runtime undermines a statically analyzable dependency graph.", "term": "Definition", "wide": true }, { "description": "[Dependency Graph](/records/architecture/dependency-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dependency-graph", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-loading", "title": "Dynamic Loading" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which replicas can converge over time without ever exposing a causally impossible state.", "term": "Definition", "wide": true }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-eventual-consistency-safety", "title": "Eventual Consistency Safety" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to choose deliberately between consistency and availability when a network partition occurs.", "term": "Definition", "wide": true }, { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-consistency-availability-choice-under-partition", "title": "Explicit Consistency/Availability Choice Under Partition" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which tracking fine-grained causal dependencies grows the dependency graph large and hard to reason about.", "term": "Definition", "wide": true }, { "description": "[Causal Dependency](/records/architecture/causal-dependency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with causal-dependency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-graph-complexity", "title": "Graph Complexity" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Reasoning about event order using logical timestamps that respect the happens-before relation.", "term": "Definition", "wide": true }, { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-happens-before-reasoning", "title": "Happens-Before Reasoning" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A dependency a component or an operation relies on without declaring it, so it surfaces only at runtime or when an unstated order is broken.", "term": "Definition", "wide": true }, { "description": "[Causal Dependency](/records/architecture/causal-dependency), [Dependency Graph](/records/architecture/dependency-graph), [Testability](/records/architecture/testability)", "term": "Referenced by" }, { "description": "[Test Pyramid Inversion](/records/architecture/test-pyramid-inversion): A hidden dependency is an undeclared requirement of a component or an operation, while test pyramid inversion is a suite weighted toward slow end-to-end tests.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Dependency](/records/architecture/causal-dependency), [Dependency Graph](/records/architecture/dependency-graph), [Testability](/records/architecture/testability), [Event Bus](/records/architecture/event-bus), [Manifest-Based Design](/records/architecture/manifest-based-design), [Dataflow Architecture](/records/architecture/dataflow-architecture), [Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-dependency", "title": "Hidden Dependency" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deliver messages to every node in the same total order.", "term": "Definition", "wide": true }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identical-delivery-order-across-nodes", "title": "Identical Delivery Order Across Nodes" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Resolving concurrent updates by keeping the most recent write, rather than merging all updates.", "term": "Definition", "wide": true }, { "description": "[CRDTs](/records/architecture/crdts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with crdts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-last-write-wins-overwrite", "title": "Last-Write-Wins Overwrite" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to weigh the latency-versus-consistency trade-off that remains even when the network is healthy.", "term": "Definition", "wide": true }, { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[PACELC Theorem](/records/architecture/pacelc-theorem)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-consistency-trade-off-when-healthy", "title": "Latency-Consistency Trade-off When Healthy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing causal ordering across replicas costs added latency and reduced availability.", "term": "Definition", "wide": true }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with causal-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-availability", "title": "Latency/Availability" }, { "blocks": [ { "items": [ "Kind: [style](/records/kind/style)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A convention of organizing components into ordered layers where each may depend only on the layers beneath it.", "term": "Definition", "wide": true }, { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layering", "title": "Layering" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A monotonically increasing counter each process maintains to stamp events for logical ordering.", "term": "Definition", "wide": true }, { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Ordering](/records/architecture/event-ordering), [Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-logical-counter", "title": "Logical Counter" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the bookkeeping a conflict-free type carries per value adds storage and transmission cost.", "term": "Definition", "wide": true }, { "description": "[CRDTs](/records/architecture/crdts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with crdts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-overhead", "title": "Metadata Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which carrying a per-node counter for every node grows the ordering metadata with cluster size.", "term": "Definition", "wide": true }, { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with vector-clocks", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-size", "title": "Metadata Size" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a distributed design account for the possibility of network partitions.", "term": "Definition", "wide": true }, { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CAP Theorem](/records/architecture/cap-theorem)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-network-partition-possibility", "title": "Network Partition Possibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a single logical counter cannot tell concurrent events apart from causally ordered ones.", "term": "Definition", "wide": true }, { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with lamport-clocks", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-no-concurrent-causality-distinction", "title": "No Concurrent Causality Distinction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each participating node have a distinct identity to index its own counter.", "term": "Definition", "wide": true }, { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-node-identity", "title": "Node Identity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each event carry a key or sequence number that fixes its position in order.", "term": "Definition", "wide": true }, { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordering-key-or-sequence", "title": "Ordering Key or Sequence" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a defined semantics specify when one event is considered to happen before another.", "term": "Definition", "wide": true }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordering-semantics", "title": "Ordering Semantics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing a happens-before order constrains how much work can run in parallel.", "term": "Definition", "wide": true }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with happens-before-relationship", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-execution", "title": "Parallel Execution" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to establish a consistent partial order over events without a shared physical clock.", "term": "Definition", "wide": true }, { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partial-ordering", "title": "Partial Ordering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting each node decide message order independently, so replicas diverge on sequence.", "term": "Definition", "wide": true }, { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Total-Order Broadcast](/records/architecture/total-order-broadcast)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-per-node-independent-ordering", "title": "Per-Node Independent Ordering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Ordering events by physical clocks alone, which clock skew renders inconsistent across nodes.", "term": "Definition", "wide": true }, { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-physical-clock-only-ordering", "title": "Physical-Clock-Only Ordering" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect data races by finding accesses with no happens-before ordering between them.", "term": "Definition", "wide": true }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-race-detection", "title": "Race Detection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for holding events that arrive early until the events before them arrive, then releasing them in order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reorder-buffer", "title": "Reorder Buffer" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming a single global clock orders all events, which fails across distributed nodes with independent clocks.", "term": "Definition", "wide": true }, { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-global-clock-assumption", "title": "Single Global Clock Assumption" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to linearize a directed acyclic graph into an order where every node follows its dependencies.", "term": "Definition", "wide": true }, { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-topological-ordering", "title": "Topological Ordering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Consuming an ordered event stream in parallel without preserving order, so state is updated out of sequence.", "term": "Definition", "wide": true }, { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Ordering](/records/architecture/event-ordering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unordered-parallel-consumption", "title": "Unordered Parallel Consumption" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Applying side effects in an order that ignores their causal dependencies, producing incorrect outcomes.", "term": "Definition", "wide": true }, { "description": "[Causality](/records/architecture/causality)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causality](/records/architecture/causality)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unordered-side-effects", "title": "Unordered Side Effects" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to guarantee that users never observe an effect before its cause.", "term": "Definition", "wide": true }, { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causal Consistency](/records/architecture/causal-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-user-visible-ordering-guarantees", "title": "User-Visible Ordering Guarantees" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "A set of per-node counters that together capture the causal history of a replicated item.", "term": "Definition", "wide": true }, { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Clocks](/records/architecture/vector-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-version-vector", "title": "Version Vector" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "Ordering distributed events by wall-clock timestamps, which clock skew makes unreliable.", "term": "Definition", "wide": true }, { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lamport Clocks](/records/architecture/lamport-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-wall-clock-ordering-assumption", "title": "Wall-Clock Ordering Assumption" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Causality / Ordering / Distributed Time](/records/lexicon-category/causality-ordering-distributed-time)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to order events causally while keeping timestamps close to wall-clock time.", "term": "Definition", "wide": true }, { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hybrid Logical Clocks](/records/architecture/hybrid-logical-clocks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-wall-clock-correlated-causal-order", "title": "Wall-Clock-Correlated Causal Order" } ], "title": "Causality / Ordering / Distributed Time" }, { "icon": "bi-book", "id": "lexicon-category-codebase-system-architecture-styles", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Components that translate between a core's ports and the specific external technologies behind them.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-adapters", "title": "Adapters" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which strict layering produces thin pass-through layers that add indirection without logic.", "term": "Definition", "wide": true }, { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with layered-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anemic-layers", "title": "Anemic Layers" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that clear boundaries separate the concentric layers of the system.", "term": "Definition", "wide": true }, { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-boundaries", "title": "Boundaries" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Funneling all state through one shared database that becomes the system's scaling bottleneck.", "term": "Definition", "wide": true }, { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-central-database-bottleneck", "title": "Central Database Bottleneck" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each component expose a well-defined boundary and interface.", "term": "Definition", "wide": true }, { "description": "[Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-component-boundaries", "title": "Component Boundaries" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reuse services across an enterprise through well-defined contracts.", "term": "Definition", "wide": true }, { "description": "[Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contract-governed-service-reuse", "title": "Contract-Governed Service Reuse" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to eliminate the shared-database bottleneck by holding state in distributed memory.", "term": "Definition", "wide": true }, { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-database-bottleneck-removal", "title": "Database-Bottleneck Removal" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for separate teams to own, deploy and evolve their services independently.", "term": "Definition", "wide": true }, { "description": "[Microservices](/records/architecture/microservices)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Microservices](/records/architecture/microservices)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decentralized-ownership", "title": "Decentralized Ownership" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that source-code dependencies point only inward, toward higher-level policy.", "term": "Definition", "wide": true }, { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" }, { "description": "[Boundaries](/records/lexicon/boundaries): The dependency rule fixes the direction dependencies point, while boundaries are the lines between the layers they cross.", "term": "Distinct from" }, { "description": "[Use Cases](/records/lexicon/use-cases): The dependency rule governs direction, while use cases are the application operations held in their own layer.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dependency-rule", "title": "Dependency Rule" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that pure domain logic occupy the core, isolated from external concerns.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-core", "title": "Domain Core" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which decomposing flow into independent filters makes tracing a request end to end harder.", "term": "Definition", "wide": true }, { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pipes-and-filters", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-end-to-end-traceability", "title": "End-to-End Traceability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to isolate the core from external systems behind adapter boundaries.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-external-system-isolation", "title": "External System Isolation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving the code that talks to a framework, vendor or protocol into an adapter behind a port.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Boundary Leakage](/records/architecture/boundary-leakage), [Framework Leakage](/records/architecture/framework-leakage), [Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Stable Interfaces](/records/architecture/stable-interfaces), [Backward Compatibility](/records/architecture/backward-compatibility), [Protocol Compatibility](/records/architecture/protocol-compatibility), [Interoperability](/records/architecture/interoperability), [Portability](/records/architecture/portability), [Protocol Independence](/records/architecture/protocol-independence), [Low Coupling](/records/architecture/low-coupling), [Replaceability](/records/architecture/replaceability), [Interchangeability](/records/architecture/interchangeability), [Model Inference](/records/architecture/model-inference), [Adapter Pattern](/records/architecture/adapter-pattern), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-adapter", "title": "Extract Adapter" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which all code serving one feature is grouped together rather than scattered by layer.", "term": "Definition", "wide": true }, { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-cohesion", "title": "Feature Cohesion" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep business rules independent of any particular framework.", "term": "Definition", "wide": true }, { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-framework-independence", "title": "Framework Independence" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a single deployable unit prevents scaling parts of the system independently.", "term": "Definition", "wide": true }, { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with monolith-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-scaling", "title": "Independent Scaling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to test each filter stage in isolation from the rest of the pipeline.", "term": "Definition", "wide": true }, { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-stage-testing", "title": "Independent Stage Testing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep the core independent of the infrastructure it runs on.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" }, { "description": "[External System Isolation](/records/lexicon/external-system-isolation): Infrastructure independence keeps the core free of the platform it runs on, while external system isolation keeps the systems it calls behind adapters.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-infrastructure-independence", "title": "Infrastructure Independence" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of upfront structural complexity introduced by defining ports and adapters.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with ports-and-adapters-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-initial-complexity", "title": "Initial Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of effort required to wire independently-developed components together.", "term": "Definition", "wide": true }, { "description": "[Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with component-based-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-integration-overhead", "title": "Integration Overhead" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring an interface owned by the core that names what it needs from the outside world.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Transaction Script Sprawl](/records/architecture/transaction-script-sprawl), [Repository Dump](/records/architecture/repository-dump), [Framework Leakage](/records/architecture/framework-leakage), [Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage), [Portability](/records/architecture/portability), [Platform Independence](/records/architecture/platform-independence), [Protocol Independence](/records/architecture/protocol-independence), [Abstraction](/records/architecture/abstraction), [Replaceability](/records/architecture/replaceability), [Independence](/records/architecture/independence), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Layered Architecture](/records/architecture/layered-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-port", "title": "Introduce Port" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting an inner layer depend on an outer one, violating the direction of the dependency rule.", "term": "Definition", "wide": true }, { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layer-leakage", "title": "Layer Leakage" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that responsibilities be divided into distinct, ordered layers.", "term": "Definition", "wide": true }, { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layer-separation", "title": "Layer Separation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Bypassing intermediate layers to call a distant layer directly, undermining the layering.", "term": "Definition", "wide": true }, { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layer-skipping", "title": "Layer Skipping" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to make a feature's changes in one place because its code is grouped together.", "term": "Definition", "wide": true }, { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-locality-of-change", "title": "Locality of Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Doing all processing in one large transform instead of a series of composable filter stages.", "term": "Definition", "wide": true }, { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-monolithic-transform-function", "title": "Monolithic Transform Function" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing framework types and annotations from the core and confining them to adapters.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Framework Leakage](/records/architecture/framework-leakage), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-framework-outward", "title": "Move Framework Outward" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a single deployable unit keeps building, deploying, and operating simple.", "term": "Definition", "wide": true }, { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-simplicity", "title": "Operational Simplicity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Organizing code by technical layer alone, scattering each feature across many packages.", "term": "Definition", "wide": true }, { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-package-by-technical-layer-only", "title": "Package by Technical Layer Only" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the core define abstract interface points through which all external interaction passes.", "term": "Definition", "wide": true }, { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Referenced by" }, { "description": "[Domain Core](/records/lexicon/domain-core): Ports are the interfaces at the edge of the core, while the domain core is the logic those interfaces enclose.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ports", "title": "Ports" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reorder or recombine independent processing stages.", "term": "Definition", "wide": true }, { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" }, { "description": "[Independent Stage Testing](/records/lexicon/independent-stage-testing): Reorderable stages can be rearranged or recombined, while independent stage testing exercises each stage alone.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reorderable-stages", "title": "Reorderable Stages" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving the code of one feature from technical-layer folders into one folder of its own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repackage-by-feature", "title": "Repackage by Feature" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that application state be kept in replicated in-memory grids rather than a central store.", "term": "Definition", "wide": true }, { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space-Based Architecture](/records/architecture/space-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replicated-in-memory-state", "title": "Replicated In-Memory State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Building one large shared application instead of composing independently-governed services.", "term": "Definition", "wide": true }, { "description": "[Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-monolithic-application", "title": "Shared Monolithic Application" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which grouping by feature complicates sharing cross-cutting technical code.", "term": "Definition", "wide": true }, { "description": "[Package by Feature](/records/architecture/package-by-feature)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with package-by-feature", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-technical-concerns", "title": "Shared Technical Concerns" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to organize code predictably by assigning each responsibility to a layer.", "term": "Definition", "wide": true }, { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layered Architecture](/records/architecture/layered-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structured-code-organization", "title": "Structured Code Organization" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to use straightforward local transactions when all state lives in one process.", "term": "Definition", "wide": true }, { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transactional-simplicity", "title": "Transactional Simplicity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the whole application build and deploy as one unit.", "term": "Definition", "wide": true }, { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unified-deployment-boundary", "title": "Unified Deployment Boundary" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that every stage share one interface so stages can be composed freely.", "term": "Definition", "wide": true }, { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipes and Filters](/records/architecture/pipes-and-filters)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uniform-stage-interface", "title": "Uniform Stage Interface" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Codebase / System Architecture Styles](/records/lexicon-category/codebase-system-architecture-styles)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that application operations be captured as explicit use cases in their own layer.", "term": "Definition", "wide": true }, { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" }, { "description": "[Boundaries](/records/lexicon/boundaries): Use cases are the operations in the application layer, while boundaries are the lines separating that layer from the others.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-use-cases", "title": "Use Cases" } ], "title": "Codebase / System Architecture Styles" }, { "icon": "bi-book", "id": "lexicon-category-contracts-interfaces-compatibility", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Exposing inconsistent, one-off endpoints instead of a uniform interface, forcing clients to special-case each.", "term": "Definition", "wide": true }, { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Referenced by" }, { "description": "[Chatty Interface](/records/architecture/chatty-interface): Ad-hoc endpoints are inconsistent one-off shapes, while a chatty interface is one operation needing many small calls.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract), [Uniform Interface](/records/architecture/uniform-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-endpoints", "title": "Ad-Hoc Endpoints" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Sending payloads with no agreed schema, so consumers must guess at structure and break on change.", "term": "Definition", "wide": true }, { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Contract](/records/architecture/schema-contract), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-payloads", "title": "Ad-Hoc Payloads" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which an API is easy for developers to learn and use correctly.", "term": "Definition", "wide": true }, { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-api-usability", "title": "API Usability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to check data automatically against a declared schema.", "term": "Definition", "wide": true }, { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-validation", "title": "Automated Validation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for changing a contract only by additions that existing consumers can ignore.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Monolith](/records/architecture/distributed-monolith), [Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-backward-compatible-change", "title": "Backward-Compatible Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Changing an API in a way that violates its published contract, breaking existing clients.", "term": "Definition", "wide": true }, { "description": "[API Contract](/records/architecture/api-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-breaking-api-change", "title": "Breaking API Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A change that violates a component's contract, forcing consumers to update to keep working.", "term": "Definition", "wide": true }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-breaking-change", "title": "Breaking Change" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of removing obsolete code and structure, which backward compatibility can hold back.", "term": "Definition", "wide": true }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with backward-compatibility, [Minimum Viable Architecture](/records/architecture/minimum-viable-architecture), [Optimization](/records/architecture/optimization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cleanup-simplification", "title": "Cleanup / Simplification" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which existing clients continue to work as an API evolves.", "term": "Definition", "wide": true }, { "description": "[API Contract](/records/architecture/api-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-client-compatibility", "title": "Client Compatibility" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for serving one client operation with one call that returns everything the operation needs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap), [Chatty Interface](/records/architecture/chatty-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coarse-grained-endpoint", "title": "Coarse-Grained Endpoint" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for serving an old contract through an adapter over the new one while consumers migrate.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change), [Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility-adapter", "title": "Compatibility Adapter" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The declared rules governing which changes are compatible and how versions are managed.", "term": "Definition", "wide": true }, { "description": "[Versioning](/records/architecture/versioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Versioning](/records/architecture/versioning)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility-policy", "title": "Compatibility Policy" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the same operation mean the same thing across every resource and endpoint.", "term": "Definition", "wide": true }, { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Referenced by" }, { "description": "[Stable Contracts](/records/lexicon/stable-contracts): Consistent semantics is one meaning across resources, while stable contracts are one shape over time.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistent-semantics", "title": "Consistent Semantics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which consumers are protected from breakage when a provider changes.", "term": "Definition", "wide": true }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-safety", "title": "Consumer Safety" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having each consumer publish the responses it relies on and testing the provider against all of them before it releases.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency), [Service Contract](/records/architecture/service-contract), [Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts), [Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-driven-contract-tests", "title": "Consumer-Driven Contract Tests" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to shape a provider's contract from the concrete needs of its consumers.", "term": "Definition", "wide": true }, { "description": "[Contract-First Design](/records/architecture/contract-first-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Contract-First Design](/records/architecture/contract-first-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-driven-development", "title": "Consumer-Driven Development" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to verify a provider still satisfies the contracts its consumers depend on.", "term": "Definition", "wide": true }, { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-verified-compatibility", "title": "Consumer-Verified Compatibility" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of testing that an implementation honors the contract it declares.", "term": "Definition", "wide": true }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Drift](/records/architecture/schema-drift), [Implicit Contract](/records/architecture/implicit-contract), [Unversioned Breaking Change](/records/architecture/unversioned-breaking-change), [Test Pyramid Inversion](/records/architecture/test-pyramid-inversion), [Mock Mirage](/records/architecture/mock-mirage), [Design by Contract](/records/architecture/design-by-contract), [Contract-First Design](/records/architecture/contract-first-design), [Postconditions](/records/architecture/postconditions), [Standards Compliance](/records/architecture/standards-compliance), [Interchangeability](/records/architecture/interchangeability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contract-testing", "title": "Contract Testing" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of mapping terms and structures between two domains that model the world differently.", "term": "Definition", "wide": true }, { "description": "[Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with semantic-contracts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-domain-translation", "title": "Cross-Domain Translation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for independent systems to exchange and understand data with one another.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-system-communication", "title": "Cross-System Communication" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which data is accurate, complete, and fit for its intended use.", "term": "Definition", "wide": true }, { "description": "[Data Contract](/records/architecture/data-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Data Contract](/records/architecture/data-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-quality", "title": "Data Quality" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for publishing the operations, shapes and guarantees of a boundary before implementing either side of it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Drift](/records/architecture/schema-drift), [Implicit Contract](/records/architecture/implicit-contract), [Distributed Monolith](/records/architecture/distributed-monolith), [Inappropriate Intimacy](/records/architecture/inappropriate-intimacy), [Pattern Cargo Cult](/records/architecture/pattern-cargo-cult), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Contract-First Design](/records/architecture/contract-first-design), [API Contract](/records/architecture/api-contract), [Schema Contract](/records/architecture/schema-contract), [Predictability](/records/architecture/predictability), [Correctness](/records/architecture/correctness), [Design Review](/records/architecture/design-review), [Self-Describing API](/records/architecture/self-describing-api), [Pipeline Architecture](/records/architecture/pipeline-architecture), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-define-contract", "title": "Define Contract" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which new functionality is built, which upfront contract rigor can slow.", "term": "Definition", "wide": true }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with design-by-contract", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-development-speed", "title": "Development Speed" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which services can evolve independently, constrained by the contracts binding them.", "term": "Definition", "wide": true }, { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with service-contract", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-evolution", "title": "Distributed Evolution" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system is tuned for one domain, traded against broad interoperability.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with interoperability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-specific-optimization", "title": "Domain-Specific Optimization" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change an interface over time, in tension with the stability its contract promises.", "term": "Definition", "wide": true }, { "description": "[API Contract](/records/architecture/api-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with api-contract", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evolution", "title": "Evolution" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which an interface can change, which a commitment to stability deliberately limits.", "term": "Definition", "wide": true }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with stable-interfaces", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evolution-speed", "title": "Evolution Speed" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A schema shaped so new fields can be added without breaking existing consumers.", "term": "Definition", "wide": true }, { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extensible-schema", "title": "Extensible Schema" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Mutating state outside an object's own boundary, breaking the invariants it is supposed to guarantee.", "term": "Definition", "wide": true }, { "description": "[Invariant](/records/architecture/invariant)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Invariant](/records/architecture/invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-external-state-mutation", "title": "External State Mutation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component permits varied use, in tension with the invariants it must uphold.", "term": "Definition", "wide": true }, { "description": "[Invariant](/records/architecture/invariant)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with invariant", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flexibility", "title": "Flexibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system accepts loosely-structured input, in tension with a strict data contract.", "term": "Definition", "wide": true }, { "description": "[Data Contract](/records/architecture/data-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with data-contract", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flexible-ingestion", "title": "Flexible Ingestion" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for announcing a removal with a date, warning the consumers still using it, and removing it after the date.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change), [Stable Interfaces](/records/architecture/stable-interfaces), [Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-gradual-deprecation", "title": "Gradual Deprecation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "An undeclared dependency between services that surfaces only at runtime, undermining independent evolution.", "term": "Definition", "wide": true }, { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-service-coupling", "title": "Hidden Service Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Integrating against a concrete implementation before agreeing a contract, coupling consumers to internals.", "term": "Definition", "wide": true }, { "description": "[Contract-First Design](/records/architecture/contract-first-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Contract-First Design](/records/architecture/contract-first-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implementation-first-integration", "title": "Implementation-First Integration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Relying on unstated preconditions a caller must satisfy, which break silently when they are violated.", "term": "Definition", "wide": true }, { "description": "[Preconditions](/records/architecture/preconditions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design by Contract](/records/architecture/design-by-contract), [Preconditions](/records/architecture/preconditions), [Interoperability](/records/architecture/interoperability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implicit-assumptions", "title": "Implicit Assumptions" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Behavior a component performs that is not stated in its contract, surprising callers who come to depend on it.", "term": "Definition", "wide": true }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implicit-behavior", "title": "Implicit Behavior" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to roll out changes gradually while old and new versions coexist.", "term": "Definition", "wide": true }, { "description": "[Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backward Compatibility](/records/architecture/backward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incremental-deployment", "title": "Incremental Deployment" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for consumers to evolve on their own schedule because the interface stays stable.", "term": "Definition", "wide": true }, { "description": "[Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stable Interfaces](/records/architecture/stable-interfaces)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-consumers", "title": "Independent Consumers" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which separate systems are connected to operate as a unified whole.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-integration", "title": "Integration" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which excessive interface abstraction adds indirection without proportional benefit.", "term": "Definition", "wide": true }, { "description": "[Interface-Based Design](/records/architecture/interface-based-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with interface-based-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interface-overuse", "title": "Interface Overuse" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for carrying data across a boundary in a transfer object, so internal models stay inside.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Boundary Leakage](/records/architecture/boundary-leakage), [Data Clumps](/records/architecture/data-clumps), [Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Explicit Contracts](/records/architecture/explicit-contracts), [Data Contract](/records/architecture/data-contract), [Schema Validation](/records/architecture/schema-validation), [Type Safety](/records/architecture/type-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-boundary-dto", "title": "Introduce Boundary DTO" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for publishing the steps a consumer takes to move from one version of a contract to the next.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-migration-guide", "title": "Migration Guide" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to serve many different clients through one compatible protocol.", "term": "Definition", "wide": true }, { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multi-client-integration", "title": "Multi-Client Integration" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which an API accepts loose or lenient input, in tension with strict preconditions.", "term": "Definition", "wide": true }, { "description": "[Preconditions](/records/architecture/preconditions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with preconditions", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-permissive-apis", "title": "Permissive APIs" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Binding to a vendor's proprietary interface, forfeiting interoperability and portability.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interoperability](/records/architecture/interoperability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-proprietary-coupling", "title": "Proprietary Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Extending a standard protocol with proprietary features until it no longer interoperates with others.", "term": "Definition", "wide": true }, { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-proprietary-drift", "title": "Proprietary Drift" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The agreed rules of a protocol, such as its messages, formats and sequences, that both ends must honor.", "term": "Definition", "wide": true }, { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-protocol-contract", "title": "Protocol Contract" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a protocol is tuned for performance, traded against broad compatibility.", "term": "Definition", "wide": true }, { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with protocol-compatibility", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-protocol-optimization", "title": "Protocol Optimization" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of freedom a provider retains to change, constrained by consumer-driven contracts.", "term": "Definition", "wide": true }, { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with consumer-driven-contracts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-provider-autonomy", "title": "Provider Autonomy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a provider can change without breaking its consumers, verified by their contracts.", "term": "Definition", "wide": true }, { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-provider-change-safety", "title": "Provider Change Safety" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of building quick throwaway prototypes, which explicit contracts can slow.", "term": "Definition", "wide": true }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with explicit-contracts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rapid-prototyping", "title": "Rapid Prototyping" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which systems integrate correctly because their shared meaning is agreed, not just their shape.", "term": "Definition", "wide": true }, { "description": "[Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Semantic Contracts](/records/architecture/semantic-contracts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-integration", "title": "Reliable Integration" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of checking that an operation's result satisfies its promised postconditions.", "term": "Definition", "wide": true }, { "description": "[Postconditions](/records/architecture/postconditions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Postconditions](/records/architecture/postconditions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-result-validation", "title": "Result Validation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to upgrade instances one at a time while old and new versions interoperate.", "term": "Definition", "wide": true }, { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rolling-upgrades", "title": "Rolling Upgrades" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of runtime overhead incurred by checking conditions on every call.", "term": "Definition", "wide": true }, { "description": "[Postconditions](/records/architecture/postconditions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with postconditions", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-cost", "title": "Runtime Cost" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change a data schema over time without breaking existing readers or writers.", "term": "Definition", "wide": true }, { "description": "[Data Contract](/records/architecture/data-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Data Contract](/records/architecture/data-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schema-evolution", "title": "Schema Evolution" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a schema tolerates variation, in tension with a strict contract.", "term": "Definition", "wide": true }, { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with schema-contract", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schema-flexibility", "title": "Schema Flexibility" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "An agreement specifying not just the shape of an interface but the meaning and behavior it guarantees.", "term": "Definition", "wide": true }, { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-semantic-contract", "title": "Semantic Contract" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Shipping a breaking change with no version bump or notice, so consumers fail without warning.", "term": "Definition", "wide": true }, { "description": "[Versioning](/records/architecture/versioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract), [Versioning](/records/architecture/versioning), [Consumer-Driven Contracts](/records/architecture/consumer-driven-contracts)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-silent-breaking-changes", "title": "Silent Breaking Changes" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which purpose-built endpoints are offered, traded against a uniform interface.", "term": "Definition", "wide": true }, { "description": "[Uniform Interface](/records/architecture/uniform-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with uniform-interface", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-specialized-endpoints", "title": "Specialized Endpoints" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving every error one published shape with a code, a message and its context.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Inconsistent Error Model](/records/architecture/inconsistent-error-model), [API Contract](/records/architecture/api-contract), [Uniform Interface](/records/architecture/uniform-interface), [Self-Describing API](/records/architecture/self-describing-api)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-standard-error-contract", "title": "Standard Error Contract" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving operations of one kind the same naming, shapes and conventions across a system.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Compatibility](/records/architecture/protocol-compatibility), [Interoperability](/records/architecture/interoperability), [Uniform Interface](/records/architecture/uniform-interface), [Composability](/records/architecture/composability), [Interchangeability](/records/architecture/interchangeability), [Pattern Consistency](/records/architecture/pattern-consistency), [Standardization](/records/architecture/standardization), [Convention over Configuration](/records/architecture/convention-over-configuration), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-standardize-the-interface", "title": "Standardize the Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Parsers that reject any input deviating from an exact expectation, breaking on benign additions.", "term": "Definition", "wide": true }, { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strict-fragile-parsers", "title": "Strict Fragile Parsers" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which input is strictly validated, in tension with tolerating unknown future fields.", "term": "Definition", "wide": true }, { "description": "[Forward Compatibility](/records/architecture/forward-compatibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with forward-compatibility", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-validation", "title": "Strong Validation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for reading only the fields a consumer needs and ignoring unknown ones, so additive changes do not break it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward Compatibility](/records/architecture/forward-compatibility), [Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tolerant-reader", "title": "Tolerant Reader" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Returning results a contract never specifies for a given input, leaving callers with undefined behavior.", "term": "Definition", "wide": true }, { "description": "[Postconditions](/records/architecture/postconditions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Postconditions](/records/architecture/postconditions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-undefined-results", "title": "Undefined Results" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for raising a contract's version number by the rule that says which kind of change it carries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unversioned Breaking Change](/records/architecture/unversioned-breaking-change)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-version-bump", "title": "Version Bump" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Contracts / Interfaces / Compatibility](/records/lexicon-category/contracts-interfaces-compatibility)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which many concurrent versions accumulate and must be maintained.", "term": "Definition", "wide": true }, { "description": "[Versioning](/records/architecture/versioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with versioning", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-version-sprawl", "title": "Version Sprawl" } ], "title": "Contracts / Interfaces / Compatibility" }, { "icon": "bi-book", "id": "lexicon-category-control-coordination-centralization", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for distributed nodes to agree on a single value despite failures.", "term": "Definition", "wide": true }, { "description": "[Consensus](/records/architecture/consensus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consensus](/records/architecture/consensus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-agreed-single-value-across-nodes", "title": "Agreed Single Value Across Nodes" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to automatically elect a new leader when the current one fails.", "term": "Definition", "wide": true }, { "description": "[Leader Election](/records/architecture/leader-election)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Leader Election](/records/architecture/leader-election)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automatic-failover-of-leadership", "title": "Automatic Failover of Leadership" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which centralizing configuration makes the whole system depend on one config source.", "term": "Definition", "wide": true }, { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with centralized-configuration", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-central-dependency-risk", "title": "Central Dependency Risk" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Routing every interaction through one central orchestrator that becomes a bottleneck and single point of failure.", "term": "Definition", "wide": true }, { "description": "[Choreography](/records/architecture/choreography)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Choreography](/records/architecture/choreography)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-central-orchestrator-bottleneck", "title": "Central Orchestrator Bottleneck" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for services to coordinate through events without a central orchestrator.", "term": "Definition", "wide": true }, { "description": "[Choreography](/records/architecture/choreography)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Choreography](/records/architecture/choreography)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-central-orchestrator-free-coordination", "title": "Central-Orchestrator-Free Coordination" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Concentrating decision-making authority in one place so nodes cannot act independently.", "term": "Definition", "wide": true }, { "description": "[Decentralization](/records/architecture/decentralization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Decentralization](/records/architecture/decentralization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-control", "title": "Centralized Control" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to manage a distributed runtime's behavior from one central control point.", "term": "Definition", "wide": true }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-control-of-distributed-runtime", "title": "Centralized Control of Distributed Runtime" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which routing a workflow through a central coordinator couples participants to it.", "term": "Definition", "wide": true }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with orchestration", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-coordinator-coupling", "title": "Centralized Coordinator Coupling" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A central store that holds configuration values for many services to read.", "term": "Definition", "wide": true }, { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-config-store", "title": "Config Store" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for validating configuration against a declared schema before the system starts.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-configuration-schema", "title": "Configuration Schema" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that directs the steps of a multi-service workflow in order.", "term": "Definition", "wide": true }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordinator", "title": "Coordinator" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which aggregating all logs centrally raises storage cost and personal-data exposure.", "term": "Definition", "wide": true }, { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with centralized-logging", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-personal-data-exposure", "title": "Cost/Personal Data Exposure" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to analyze behavior across services by querying their aggregated logs.", "term": "Definition", "wide": true }, { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-service-analysis", "title": "Cross-Service Analysis" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving values that vary by environment out of code into configuration read at startup.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration), [Magic Value](/records/architecture/magic-value), [Environment Parity](/records/architecture/environment-parity), [Containerization](/records/architecture/containerization), [Configuration Externalization](/records/architecture/configuration-externalization), [Declarative Configuration](/records/architecture/declarative-configuration), [Resource Utilization](/records/architecture/resource-utilization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-externalize-configuration", "title": "Externalize Configuration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Leaving control fully decentralized with no central plane, so global runtime policy cannot be coordinated.", "term": "Definition", "wide": true }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fully-decentralized-control", "title": "Fully Decentralized Control" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A central service that authenticates identities and issues credentials for others to trust.", "term": "Definition", "wide": true }, { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-provider", "title": "Identity Provider" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which every login depends on the central identity provider staying available.", "term": "Definition", "wide": true }, { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with centralized-authentication", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-provider-availability", "title": "Identity Provider Availability" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting each node decide independently with no agreement, so they diverge on shared state.", "term": "Definition", "wide": true }, { "description": "[Consensus](/records/architecture/consensus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consensus](/records/architecture/consensus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-node-decisions", "title": "Independent Node Decisions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for each node or team to own and control its part without central approval.", "term": "Definition", "wide": true }, { "description": "[Decentralization](/records/architecture/decentralization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Decentralization](/records/architecture/decentralization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-ownership", "title": "Independent Ownership" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Leaving logs scattered on each host with no aggregation, so cross-service analysis is impossible.", "term": "Definition", "wide": true }, { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-only-logs", "title": "Local-Only Logs" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that collects logs from many sources into one central store.", "term": "Definition", "wide": true }, { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Logging](/records/architecture/centralized-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-log-aggregation", "title": "Log Aggregation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A programmatic interface through which operators manage a distributed runtime's state.", "term": "Definition", "wide": true }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Control Plane](/records/architecture/control-plane), [Decentralization](/records/architecture/decentralization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-management-api", "title": "Management API" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to execute the steps of a workflow in a defined order.", "term": "Definition", "wide": true }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordered-multi-step-execution", "title": "Ordered Multi-Step Execution" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Coordinating a multi-step workflow purely through choreography when central orchestration is needed, scattering its logic.", "term": "Definition", "wide": true }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pure-choreography", "title": "Pure Choreography" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a majority of nodes agree before a decision commits.", "term": "Definition", "wide": true }, { "description": "[Consensus](/records/architecture/consensus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consensus](/records/architecture/consensus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quorum", "title": "Quorum" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Reimplementing authentication separately in each service instead of centralizing it.", "term": "Definition", "wide": true }, { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scattered-auth-implementations", "title": "Scattered Auth Implementations" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Spreading configuration across many services with no single source, so values drift out of sync.", "term": "Definition", "wide": true }, { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Control Plane](/records/architecture/control-plane), [Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scattered-configuration", "title": "Scattered Configuration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "[Leader Election](/records/architecture/leader-election), [Write Barrier](/records/architecture/write-barrier)", "term": "Referenced by" }, { "description": "[Automatic Failover of Leadership](/records/lexicon/automatic-failover-of-leadership): Single-writer coordination makes one elected node the only writer, while leadership failover elects a new one when it fails.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Leader Election](/records/architecture/leader-election), [Write Barrier](/records/architecture/write-barrier)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-writer-coordination", "title": "Single-Writer Coordination" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Two nodes both believing they are leader and acting independently, corrupting shared state.", "term": "Definition", "wide": true }, { "description": "[Leader Election](/records/architecture/leader-election)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Leader Election](/records/architecture/leader-election)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-brain-coordination", "title": "Split-Brain Coordination" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to manage all services' configuration from one place.", "term": "Definition", "wide": true }, { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Configuration](/records/architecture/centralized-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unified-config-management", "title": "Unified Config Management" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Control / Coordination / Centralization](/records/lexicon-category/control-coordination-centralization)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to give users one identity recognized across all services.", "term": "Definition", "wide": true }, { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Centralized Authentication](/records/architecture/centralized-authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unified-identity", "title": "Unified Identity" } ], "title": "Control / Coordination / Centralization" }, { "icon": "bi-book", "id": "lexicon-category-coordination-surfaces", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a surface that receives what a record extracts before the record is deleted, so a deletion loses nothing a later reader needs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-accumulator", "title": "Accumulator" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the party a record names to close it when its satisfaction is a judgment, required where no artifact resolves the record and forbidden where one does.", "term": "Definition", "wide": true }, { "description": "[Derived Record State](/records/architecture/derived-record-state)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Record State](/records/architecture/derived-record-state)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-acknowledger", "title": "Acknowledger" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for assigning a record its id when it is created and never deriving it again from its location or subject.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declared Subject](/records/architecture/declared-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-allocate-identity-once", "title": "Allocate Identity Once" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a closed venue to the archive once its outcome is absorbed, instead of deleting it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Destructive Closure](/records/architecture/destructive-closure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-archive-the-absorbed-venue", "title": "Archive the Absorbed Venue" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which the one-writer invariant is assumed to cover a jointly authored surface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assumed-single-writer", "title": "Assumed Single Writer" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a second caller attaches to a running process instead of reading the result that process publishes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Read-Time Join](/records/architecture/read-time-join)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-attached-second-caller", "title": "Attached Second Caller" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which every copy is collapsed toward its source without asking whether any edge ever runs again.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blanket-collapse", "title": "Blanket Collapse" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a reader handed a task and whatever its host injects, never a coordination surface, which ends by returning its result.", "term": "Definition", "wide": true }, { "description": "[Projection Channel](/records/architecture/projection-channel)", "term": "Referenced by" }, { "description": "[Host Projection](/records/lexicon/host-projection): A bounded reader is the party spawned for a task, while the host projection is the one line of context it receives about the surfaces.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-reader", "title": "Bounded Reader" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a field whose consumers are mechanisms and whose value is drawn from a closed set or is an identifier.", "term": "Definition", "wide": true }, { "description": "[Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Referenced by" }, { "description": "[Payload Field](/records/lexicon/payload-field): A carrier field is read by mechanisms, while a payload field is read only by a reader.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-carrier-field", "title": "Carrier Field" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking that every index entry resolves to a file and that every file has an entry.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Two-Direction Index](/records/architecture/two-direction-index)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-check-both-directions", "title": "Check Both Directions" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking that a projection holds only the shape its name claims.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-check-the-projection-s-shape", "title": "Check the Projection's Shape" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for enforcing a change rule by comparing the content before and after the change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compare-the-two-readings", "title": "Compare the Two Readings" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of how a body of work divides into concerns, derived from a coupling relation that joins two surfaces when a change to one forces a change to the other.", "term": "Definition", "wide": true }, { "description": "[Derived Party Count](/records/architecture/derived-party-count)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Party Count](/records/architecture/derived-party-count)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concern-partition", "title": "Concern Partition" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one declared scope is used both to detect collisions and to decide whether a result answers a later question.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-conflated-scope", "title": "Conflated Scope" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of one addressable claim inside a coordination surface, carrying its schema fields, its edges, an allocated id, a declared subject and the one writer it names.", "term": "Definition", "wide": true }, { "description": "[Derived Record State](/records/architecture/derived-record-state), [Declared Subject](/records/architecture/declared-subject)", "term": "Referenced by" }, { "description": "[Acknowledger](/records/lexicon/acknowledger): A coordination record is the claim itself, while the acknowledger is the party a record names to close it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Record State](/records/architecture/derived-record-state), [Declared Subject](/records/architecture/declared-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordination-record", "title": "Coordination Record" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a file that parties read and write to coordinate work, carrying a declared key and scope in its header and records each owned by one writer.", "term": "Definition", "wide": true }, { "description": "[Stated Invariant](/records/architecture/stated-invariant), [Write Barrier](/records/architecture/write-barrier), [Two-Direction Index](/records/architecture/two-direction-index), [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant), [Write Barrier](/records/architecture/write-barrier), [Two-Direction Index](/records/architecture/two-direction-index), [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordination-surface", "title": "Coordination Surface" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for counting the copies that differ from their source before deciding which way to collapse them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-count-distinguished-copies", "title": "Count Distinguished Copies" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for setting the party count to the number of concerns the derived partition holds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Party Count](/records/architecture/derived-party-count)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-count-the-partition-s-concerns", "title": "Count the Partition's Concerns" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which parties are added who all reason about the same surface.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-crowded-surface", "title": "Crowded Surface" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring each surface's lifetime with a value from the closed set of every axis, so no axis is inferred.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-all-three-lifetime-axes", "title": "Declare All Three Lifetime Axes" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring the lifetime of every section that lives differently from its file's default.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-each-divergent-section", "title": "Declare Each Divergent Section" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring that a mandated prose field is written for people, so no consumer is assumed to read it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-field-for-readers", "title": "Declare the Field for Readers" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stating the lifetime a file's sections take unless a section declares its own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-file-default", "title": "Declare the File Default" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring on a jointly authored surface that the one-writer invariant has no operand there.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-missing-operand", "title": "Declare the Missing Operand" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording which party removes a channel, so every channel has a party that can attribute it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-remover", "title": "Declare the Remover" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording a record's subject as a declared field next to its id, so either can change without breaking the other.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declared Subject](/records/architecture/declared-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-subject-beside-the-id", "title": "Declare the Subject Beside the Id" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for publishing the part of a surface a run writes, so overlapping runs are detected.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-write-scope", "title": "Declare the Write Scope" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a surface is updated and its projection is left for a later change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-projection", "title": "Deferred Projection" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a host setting declared as given later, which blocks every check that depends on it until it is given, while an absent setting turns those checks off.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-setting", "title": "Deferred Setting" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of how often a derivation edge runs, on every read, between stores or once at creation, which decides whether a copy is stale or is a record.", "term": "Definition", "wide": true }, { "description": "[Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-derivation-period", "title": "Derivation Period" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for computing liveness in one place that every consumer reads.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-derive-liveness-once", "title": "Derive Liveness Once" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing a written status field and computing a record's state from the edges that connect it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Record State](/records/architecture/derived-record-state), [Written Status Marker](/records/architecture/written-status-marker)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-derive-state-from-edges", "title": "Derive State from Edges" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deriving the partition of work from the surfaces involved before choosing how many parties take part.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Party Count](/records/architecture/derived-party-count)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-derive-the-partition", "title": "Derive the Partition" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a channel is named by a digest of its scope, which separates channels but cannot be decoded.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-digest-named-channel", "title": "Digest-Named Channel" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the one copy of a fact that every other copy derives from, or the one copy a mechanism resolves, which gives a set of copies its direction.", "term": "Definition", "wide": true }, { "description": "[Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Referenced by" }, { "description": "[Derivation Period](/records/lexicon/derivation-period): A distinguished copy gives a set of copies its direction, while the derivation period decides what the other copies are.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distinguished-copy", "title": "Distinguished Copy" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for making a mandated field take a value from a declared closed set that a consumer can join on.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-draw-the-value-from-a-closed-set", "title": "Draw the Value from a Closed Set" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a run is started for a question a live run's scope already covers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Read-Time Join](/records/architecture/read-time-join)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicate-covered-run", "title": "Duplicate Covered Run" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for naming a channel by an encoding of its scope that can be decoded back to the scope.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-encode-the-scope-reversibly", "title": "Encode the Scope Reversibly" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A measure of how many parties' claims rest on one surface, read from who authored each claim, whom it addressed and which surfaces it cites.", "term": "Definition", "wide": true }, { "description": "[Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fan-in", "title": "Fan-In" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a jointly authored surface is fenced into per-party spans.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fenced-joint-surface", "title": "Fenced Joint Surface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one lifetime is stated for a file whose sections live differently, so the file's word authorizes operations on a part that forbids them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-file-wide-lifetime", "title": "File-Wide Lifetime" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for producing an index by reading the directory it describes instead of editing entries by hand.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Two-Direction Index](/records/architecture/two-direction-index), [Hand-Kept Index](/records/architecture/hand-kept-index)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-generate-the-index-from-the-directory", "title": "Generate the Index from the Directory" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to remove content only where its declared lifetime names the party or mechanism allowed to remove it.", "term": "Definition", "wide": true }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-governed-removal", "title": "Governed Removal" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for taking an exclusive write on a shared surface only after every peer is observed parked.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Barrier](/records/architecture/write-barrier)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hold-the-barrier-for-planned-writes", "title": "Hold the Barrier for Planned Writes" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the coordination graph that a host injects into every bounded reader's context, the only channel through which such a reader learns anything about the surfaces.", "term": "Definition", "wide": true }, { "description": "[Projection Channel](/records/architecture/projection-channel)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-host-projection", "title": "Host Projection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for waiting on another run by reading the result it publishes instead of attaching to its process.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Read-Time Join](/records/architecture/read-time-join)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-join-by-reading-the-published-result", "title": "Join by Reading the Published Result" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a caller that reads a live run's published result and its standing instead of starting a run of its own, with an empty write set.", "term": "Definition", "wide": true }, { "description": "[Read-Time Join](/records/architecture/read-time-join)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Read-Time Join](/records/architecture/read-time-join)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-joiner", "title": "Joiner" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for holding one aggregate report per subject, with no report named for a scope or caller beside it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Invocation-Keyed Report](/records/architecture/invocation-keyed-report)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-keep-one-aggregate", "title": "Keep One Aggregate" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping the fields only people read as prose that no mechanism parses.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-leave-the-payload-prose", "title": "Leave the Payload Prose" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that answers whether a process is still running by checking that the process is present, so its absence proves death while its presence proves nothing.", "term": "Definition", "wide": true }, { "description": "[One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-liveness-witness", "title": "Liveness Witness" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a record's identity is derived from its location or its subject, so renaming either one breaks it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declared Subject](/records/architecture/declared-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-location-derived-identity", "title": "Location-Derived Identity" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stamping each claim with the moment its surface was read, so a stale claim is recognized.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mark-claims-with-their-read-moment", "title": "Mark Claims with Their Read Moment" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for marking an invariant that nothing enforces as unheld, together with every derivation that rests on it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mark-the-invariant-unheld", "title": "Mark the Invariant Unheld" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the lifetime axis that states whether a landed statement may be rewritten, and by whom, its own writer or nobody.", "term": "Definition", "wide": true }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Referenced by" }, { "description": "[Removal Authority](/records/lexicon/removal-authority): Mutability states whether landed content may be rewritten, while removal authority states who may take it out.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mutability", "title": "Mutability" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for naming, for each stated invariant, the party or check that objects when it stops holding.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-name-the-objector", "title": "Name the Objector" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an index is checked in one direction only, so an entry with no file or a file with no entry goes unnoticed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Two-Direction Index](/records/architecture/two-direction-index)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-one-way-index-check", "title": "One-Way Index Check" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a surface that carries one product authored jointly, such as a contract or a class statement, with no per-party unit an ownership fence could range over.", "term": "Definition", "wide": true }, { "description": "[Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-outcome-surface", "title": "Outcome Surface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a projection grows past the shape its name claims.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-overgrown-projection", "title": "Overgrown Projection" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a reader that owns surfaces and an inbox, receives both, and waits between turns instead of ending.", "term": "Definition", "wide": true }, { "description": "[Bounded Reader](/records/lexicon/bounded-reader): A participant owns surfaces and waits between turns, while a bounded reader owns nothing and ends by returning.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-participant", "title": "Participant" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a surface that too many parties reason about into surfaces with fewer readers each.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Fan-In Ceiling](/records/architecture/fan-in-ceiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partition-the-surface", "title": "Partition the Surface" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a field whose only consumer is a reader and which no parser reaches without a heuristic.", "term": "Definition", "wide": true }, { "description": "[Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-payload-field", "title": "Payload Field" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which each consumer computes liveness separately, so two consumers of one question reach different answers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-per-consumer-liveness", "title": "Per-Consumer Liveness" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a party count is chosen as a preference and work is allocated to fit it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Derived Party Count](/records/architecture/derived-party-count)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-preferred-party-count", "title": "Preferred Party Count" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a process that is present is treated as alive.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-presence-as-liveness", "title": "Presence as Liveness" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a mechanism interprets prose to compute a fact.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prose-parsing-mechanism", "title": "Prose-Parsing Mechanism" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for publishing what a run read, so a later question can tell whether the run's result answers it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-publish-the-read-population", "title": "Publish the Read Population" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for regenerating every copy of an invariant from its source whenever the source changes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-re-derive-every-copy-on-change", "title": "Re-Derive Every Copy on Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a run reads the set of live runs before writing its own entry, so two starters each see an empty set.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-before-declare", "title": "Read Before Declare" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking, for each copy, whether the edge that produced it runs again or ran once against an earlier state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-each-period", "title": "Read Each Period" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the set a run read and publishes with its result, which a later caller tests to decide whether that result answers its own question.", "term": "Definition", "wide": true }, { "description": "[Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Read-Time Join](/records/architecture/read-time-join), [Single Aggregate](/records/architecture/single-aggregate)", "term": "Referenced by" }, { "description": "[Joiner](/records/lexicon/joiner): A read population is what a run measured, while a joiner is the later caller that relies on it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Read-Time Join](/records/architecture/read-time-join), [Single Aggregate](/records/architecture/single-aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-population", "title": "Read Population" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to catch a record written a second time about a subject another record already holds.", "term": "Definition", "wide": true }, { "description": "[Declared Subject](/records/architecture/declared-subject)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declared Subject](/records/architecture/declared-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rederivation-detection", "title": "Rederivation Detection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for updating a projection in the same change that moves the fact it summarizes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Projection Channel](/records/architecture/projection-channel)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-refresh-the-projection-in-the-same-change", "title": "Refresh the Projection in the Same Change" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for refusing to collapse a set of copies with no distinguished member and reporting the cycle by name.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Cyclic Tiebreak](/records/architecture/cyclic-tiebreak)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-refuse-and-name-the-cycle", "title": "Refuse and Name the Cycle" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a checker keeps its own prior output to judge a change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remembering-checker", "title": "Remembering Checker" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the lifetime axis that states who may take content out, whether nobody at any point, its writer, the party that discharged it, or the mechanism that regenerates it.", "term": "Definition", "wide": true }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-removal-authority", "title": "Removal Authority" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deleting payload text that restates what its carrier already answers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remove-the-restating-payload", "title": "Remove the Restating Payload" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for fixing a defect at the source every copy derives from instead of in the copies.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Period-Decided Disposition](/records/architecture/period-decided-disposition)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repair-the-source", "title": "Repair the Source" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a payload restates a question its carrier already answers.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-restating-payload", "title": "Restating Payload" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping the earlier state of content in the layer that spans both states, so a change rule can compare them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retain-the-prior-state-in-the-spanning-layer", "title": "Retain the Prior State in the Spanning Layer" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the lifetime axis that states what ends a piece of content, whether nothing, a newer version of itself, the completion of what it asked for, or its producer regenerating the whole surface.", "term": "Definition", "wide": true }, { "description": "[Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Referenced by" }, { "description": "[Mutability](/records/lexicon/mutability): Retention states what ends a piece of content, while mutability states whether landed content may be rewritten.", "term": "Distinct from" }, { "description": "[Removal Authority](/records/lexicon/removal-authority): Retention states what ends a piece of content, while removal authority states who may take it out.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes), [Section Lifetime Divergence](/records/architecture/section-lifetime-divergence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retention", "title": "Retention" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for resolving concurrent work on a jointly authored surface by each party announcing its claim before acting.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-settle-collisions-by-announcement", "title": "Settle Collisions by Announcement" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for several callers to share one run of a measurement, each either joining a live run that covers its question or starting one that no live run covers.", "term": "Definition", "wide": true }, { "description": "[Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Read-Time Join](/records/architecture/read-time-join), [One-Sided Liveness](/records/architecture/one-sided-liveness), [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Read-Time Join](/records/architecture/read-time-join), [One-Sided Liveness](/records/architecture/one-sided-liveness), [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-invocation", "title": "Shared Invocation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a rule about how content changes is enforced by a check that reads one state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [State-Arity Limit](/records/architecture/state-arity-limit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-state-change-check", "title": "Single-State Change Check" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a lifetime is declared as one word, so a reader infers its other two axes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Independent Lifetime Axes](/records/architecture/independent-lifetime-axes)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-word-lifetime", "title": "Single-Word Lifetime" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a record satisfied by judgment and left unacknowledged past a declared number of rounds is a finding, a bound on its lifetime rather than its size.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stall-bound", "title": "Stall Bound" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for returning the verdicts of a narrowed run to its caller instead of writing them as a report.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Single Aggregate](/records/architecture/single-aggregate), [Invocation-Keyed Report](/records/architecture/invocation-keyed-report)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stream-narrowed-verdicts", "title": "Stream Narrowed Verdicts" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking whether a live run's scope already covers a question before starting a new run.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Read-Time Join](/records/architecture/read-time-join)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-test-coverage-first", "title": "Test Coverage First" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to trace every guarantee a topology offers back to a stated property and the mechanism that would object if it stopped holding.", "term": "Definition", "wide": true }, { "description": "[Stated Invariant](/records/architecture/stated-invariant), [Derived Record State](/records/architecture/derived-record-state), [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface), [Projection Channel](/records/architecture/projection-channel), [Two-Direction Index](/records/architecture/two-direction-index), [Period-Decided Disposition](/records/architecture/period-decided-disposition), [Derived Party Count](/records/architecture/derived-party-count), [Fan-In Ceiling](/records/architecture/fan-in-ceiling), [State-Arity Limit](/records/architecture/state-arity-limit), [Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Joinable Mandated Field](/records/architecture/joinable-mandated-field), [Single Aggregate](/records/architecture/single-aggregate)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant), [Derived Record State](/records/architecture/derived-record-state), [Operand-Free Outcome Surface](/records/architecture/operand-free-outcome-surface), [Projection Channel](/records/architecture/projection-channel), [Two-Direction Index](/records/architecture/two-direction-index), [Period-Decided Disposition](/records/architecture/period-decided-disposition), [Derived Party Count](/records/architecture/derived-party-count), [Fan-In Ceiling](/records/architecture/fan-in-ceiling), [State-Arity Limit](/records/architecture/state-arity-limit), [Carrier and Payload Split](/records/architecture/carrier-and-payload-split), [Joinable Mandated Field](/records/architecture/joinable-mandated-field), [Single Aggregate](/records/architecture/single-aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-traceable-guarantee", "title": "Traceable Guarantee" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for treating every statement of one invariant as a single unit that one query ranges over.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Contradicted Invariant](/records/architecture/contradicted-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-treat-the-statements-as-one-unit", "title": "Treat the Statements as One Unit" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving the fields a mechanism reads a resolvable typed form.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Carrier and Payload Split](/records/architecture/carrier-and-payload-split)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-type-the-carrier", "title": "Type the Carrier" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a system relies on a property that nothing would notice losing.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unobjected-invariant", "title": "Unobjected Invariant" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a field is mandated as free prose while a consumer is assumed to read it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Joinable Mandated Field](/records/architecture/joinable-mandated-field)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unread-prose-mandate", "title": "Unread Prose Mandate" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an invariant is stated in a surface its bound parties never receive.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Stated Invariant](/records/architecture/stated-invariant)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unreceived-invariant", "title": "Unreceived Invariant" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a surface opened for one discussion, which declares its own exit condition and moves to the archive once the outcome it produced has landed.", "term": "Definition", "wide": true }, { "description": "[Outcome Surface](/records/lexicon/outcome-surface): A venue holds the discussion and leaves the active surface once its outcome is absorbed, while the outcome surface is where the agreed result survives.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-venue", "title": "Venue" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a shared surface is rewritten whole while a peer is still active on it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Barrier](/records/architecture/write-barrier)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-whole-surface-rewrite", "title": "Whole-Surface Rewrite" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for applying a time window to a liveness witness only after the witness is read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-window-second", "title": "Window Second" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deciding liveness from a witness the process writes, never from the process being present.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [One-Sided Liveness](/records/architecture/one-sided-liveness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-witness-first", "title": "Witness First" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the set of paths a run declares it may write, compared by declaration before the run begins to decide whether two runs collide.", "term": "Definition", "wide": true }, { "description": "[Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding), [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Referenced by" }, { "description": "[Read Population](/records/lexicon/read-population): A write scope decides whether two runs may proceed at once, while a read population decides whether a published result answers a later question.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Write Scope and Read Population](/records/architecture/write-scope-and-read-population), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding), [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-write-scope", "title": "Write Scope" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for overwriting an aggregate report only from a run that measured its whole population.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Single Aggregate](/records/architecture/single-aggregate), [Narrowed Aggregate](/records/architecture/narrowed-aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-write-the-aggregate-only-from-a-full-run", "title": "Write the Aggregate Only from a Full Run" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Coordination Surfaces](/records/lexicon-category/coordination-surfaces)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing a run's own entry before reading the set of live runs, so two starters see each other.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the coordination member's surface, record and declaration rules, [Declare-Before-Read Order](/records/architecture/declare-before-read-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-write-the-entry-before-reading-the-set", "title": "Write the Entry Before Reading the Set" } ], "title": "Coordination Surfaces" }, { "icon": "bi-book", "id": "lexicon-category-core-modular-design", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for a team or module to own and control one bounded part of the system.", "term": "Definition", "wide": true }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-context-ownership", "title": "Bounded Context Ownership" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each piece of knowledge have one authoritative definition rather than copies.", "term": "Definition", "wide": true }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-canonical-source", "title": "Canonical Source" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for gathering every copy of one rule into a single definition that the copies are replaced by.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shotgun Surgery](/records/architecture/shotgun-surgery), [Stringly Typed Programming](/records/architecture/stringly-typed-programming), [Magic Value](/records/architecture/magic-value), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Convention over Configuration](/records/architecture/convention-over-configuration), [Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralize-the-rule", "title": "Centralize the Rule" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Concentrating runtime control in one place so otherwise-independent modules cannot act without it.", "term": "Definition", "wide": true }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" }, { "description": "[Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency): Centralized runtime control makes modules unable to act without one controller, while a cyclic deployment dependency makes services deploy in lockstep.", "term": "Distinct from" }, { "description": "[Shared Database](/records/lexicon/shared-database): Centralized runtime control concentrates control flow, while a shared database concentrates data.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-runtime-control", "title": "Centralized Runtime Control" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to confine the impact of a change behind a boundary so callers are unaffected.", "term": "Definition", "wide": true }, { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Referenced by" }, { "description": "[Invariant Protection](/records/lexicon/invariant-protection): Change isolation keeps a change from reaching callers, while invariant protection keeps an object's rules holding.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-change-isolation", "title": "Change Isolation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for merging layers that only pass calls through, so a simple operation crosses fewer boundaries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Middle Man](/records/architecture/middle-man), [Over-Abstraction](/records/architecture/over-abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-collapse-layers", "title": "Collapse Layers" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Baking one caller's specific assumptions into a component, preventing its reuse elsewhere.", "term": "Definition", "wide": true }, { "description": "[Reusability](/records/architecture/reusability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reusability](/records/architecture/reusability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-specific-coupling", "title": "Context-Specific Coupling" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that every alternative implementation fully honor the same interface contract.", "term": "Definition", "wide": true }, { "description": "Interface Conformance", "term": "Aliases" }, { "description": "[Contract Compatibility](/records/algorithms/contract-compatibility)", "term": "Contract" }, { "description": "[Interchangeability](/records/architecture/interchangeability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interchangeability](/records/architecture/interchangeability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contract-compatibility", "title": "Contract Compatibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of extra coordination required when components are made fully independent.", "term": "Definition", "wide": true }, { "description": "[Independence](/records/architecture/independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with independence", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordination-cost", "title": "Coordination Cost" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Duplicating code by copying and pasting instead of extracting a shared abstraction.", "term": "Definition", "wide": true }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-copy-paste-programming", "title": "Copy-Paste Programming" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting a concern such as logging or security bleed into unrelated modules throughout the code.", "term": "Definition", "wide": true }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Referenced by" }, { "description": "[Mixed Layers](/records/lexicon/mixed-layers): Cross-cutting leakage spreads one concern such as logging through many modules, while mixed layers put several layers' logic in one place.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-cutting-leakage", "title": "Cross-Cutting Leakage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Stacking many layers of subclassing, so behavior is scattered and fragile to change.", "term": "Definition", "wide": true }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deep-inheritance-hierarchy", "title": "Deep Inheritance Hierarchy" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of optimizing heavily against a specific implementation's traits, which ties code to it.", "term": "Definition", "wide": true }, { "description": "[Replaceability](/records/architecture/replaceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with replaceability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deep-optimization", "title": "Deep Optimization" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring which module owns each piece of code and which entry points other modules may use.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud), [Separation of Concerns](/records/architecture/separation-of-concerns), [Modularity](/records/architecture/modularity), [Greenfield Development](/records/architecture/greenfield-development), [Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-define-module-boundaries", "title": "Define Module Boundaries" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Forwarding work to a contained collaborator object rather than inheriting the behavior.", "term": "Definition", "wide": true }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delegation", "title": "Delegation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for making a module's state private and exposing only operations that keep its rules.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state), [Feature Envy](/records/architecture/feature-envy), [Anemic Domain Model](/records/architecture/anemic-domain-model), [Invariant](/records/architecture/invariant), [Determinism](/records/architecture/determinism), [Encapsulation](/records/architecture/encapsulation), [State Isolation](/records/architecture/state-isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-encapsulate-state", "title": "Encapsulate State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which splitting responsibilities too finely scatters logic across many small units.", "term": "Definition", "wide": true }, { "description": "[Single Responsibility Principle (SRP)](/records/architecture/single-responsibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with single-responsibility", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-excessive-fragmentation", "title": "Excessive Fragmentation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring what a module needs as parameters or imports instead of reaching it through global state.", "term": "Definition", "wide": true }, { "description": "[Explicit Dependencies](/records/lexicon/explicit-dependencies): Explicit dependency is the technique of declaring what a module needs, while explicit dependencies is the degree to which a component's needs are visible.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Action at a Distance](/records/architecture/action-at-a-distance), [Causal Dependency](/records/architecture/causal-dependency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-dependency", "title": "Explicit Dependency" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a module interact only through declared interfaces, not its hidden internals.", "term": "Definition", "wide": true }, { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-interfaces", "title": "Explicit Interfaces" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "Anemic Encapsulation", "term": "Aliases" }, { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Referenced by" }, { "description": "[Feature Envy](/records/architecture/feature-envy): Exposed internals are a module opening its own details, while feature envy is a module working mostly on another's data.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutability](/records/architecture/immutability), [Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding), [Introspection](/records/architecture/introspection), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exposed-internals", "title": "Exposed Internals" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a cohesive group of fields and methods out of a class into a new class of their own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[God Object](/records/architecture/god-object), [Divergent Change](/records/architecture/divergent-change), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [High Cohesion](/records/architecture/high-cohesion)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-class", "title": "Extract Class" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a fragment of a long function into a named function of its own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Encapsulation](/records/architecture/encapsulation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-function", "title": "Extract Function" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving one responsibility out of a module into a new module with its own entry point.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shotgun Surgery](/records/architecture/shotgun-surgery), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Separation of Concerns](/records/architecture/separation-of-concerns), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Composability](/records/architecture/composability), [Reusability](/records/architecture/reusability), [Model Inference](/records/architecture/model-inference), [Component-Based Architecture](/records/architecture/component-based-architecture), [Package by Feature](/records/architecture/package-by-feature)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-module", "title": "Extract Module" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding a method on an object that forwards to the object behind it, so clients stop navigating the chain.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Chain](/records/architecture/message-chain)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hide-delegate", "title": "Hide Delegate" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Defining an interface around one implementation's quirks, so no alternative can satisfy it.", "term": "Definition", "wide": true }, { "description": "[Interchangeability](/records/architecture/interchangeability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composability](/records/architecture/composability), [Interchangeability](/records/architecture/interchangeability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implementation-specific-contracts", "title": "Implementation-Specific Contracts" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to test a component in isolation without standing up its collaborators.", "term": "Definition", "wide": true }, { "description": "Test Isolation", "term": "Aliases" }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Independence](/records/architecture/independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Low Coupling](/records/architecture/low-coupling), [Independence](/records/architecture/independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-testing", "title": "Independent Testing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing an interface, layer or wrapper that adds no policy and calling its single implementation directly.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Middle Man](/records/architecture/middle-man), [Speculative Generality](/records/architecture/speculative-generality), [Over-Abstraction](/records/architecture/over-abstraction), [Architecture Astronaut](/records/architecture/architecture-astronaut)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inline-abstraction", "title": "Inline Abstraction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an abstraction expose a defined interface separate from its implementation.", "term": "Definition", "wide": true }, { "description": "[Abstraction](/records/architecture/abstraction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interface-definition", "title": "Interface Definition" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to rework a module's internals freely as long as its interface stays stable.", "term": "Definition", "wide": true }, { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-internal-refactoring", "title": "Internal Refactoring" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing a group of parameters that travel together with one named object.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Boolean Trap](/records/architecture/boolean-trap), [Long Parameter List](/records/architecture/long-parameter-list), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Reusability](/records/architecture/reusability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-parameter-object", "title": "Introduce Parameter Object" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to guarantee an object's rules always hold by controlling all access to its state.", "term": "Definition", "wide": true }, { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encapsulation](/records/architecture/encapsulation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invariant-protection", "title": "Invariant Protection" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "An abstraction that forces callers to understand its underlying implementation to use it correctly.", "term": "Definition", "wide": true }, { "description": "[Information Hiding](/records/architecture/information-hiding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Information Hiding](/records/architecture/information-hiding), [Abstraction](/records/architecture/abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-leaky-abstraction", "title": "Leaky Abstraction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which keeping related behavior together can conflict with removing all duplication.", "term": "Definition", "wide": true }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with duplicate-code", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-locality-of-behavior", "title": "Locality of Behavior" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for confining a change of global behavior to the scope that needs it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Action at a Distance](/records/architecture/action-at-a-distance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-localize-effect", "title": "Localize Effect" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Interleaving different architectural layers' logic in one place instead of keeping each concern separate.", "term": "Definition", "wide": true }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mixed-layers", "title": "Mixed Layers" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Writing large all-in-one procedures that cannot be recombined from smaller, independent parts.", "term": "Definition", "wide": true }, { "description": "[Composability](/records/architecture/composability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composability](/records/architecture/composability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-monolithic-procedures", "title": "Monolithic Procedures" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a method or function to the module that owns the data it reads and writes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[God Object](/records/architecture/god-object), [Shotgun Surgery](/records/architecture/shotgun-surgery), [Divergent Change](/records/architecture/divergent-change), [Feature Envy](/records/architecture/feature-envy), [Message Chain](/records/architecture/message-chain), [Utility Dump](/records/architecture/utility-dump), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Separation of Concerns](/records/architecture/separation-of-concerns), [High Cohesion](/records/architecture/high-cohesion), [Layered Architecture](/records/architecture/layered-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-behavior-to-its-owner", "title": "Move Behavior to Its Owner" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which making code reusable for every case adds abstraction that harms clarity.", "term": "Definition", "wide": true }, { "description": "[Reusability](/records/architecture/reusability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with reusability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-over-generalization", "title": "Over-Generalization" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which adding separating layers introduces indirection that outweighs the separation gained.", "term": "Definition", "wide": true }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with separation-of-concerns", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-over-layering", "title": "Over-Layering" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which pursuing tight cohesion can narrow a unit's purpose too far to reuse.", "term": "Definition", "wide": true }, { "description": "[High Cohesion](/records/architecture/high-cohesion)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with high-cohesion", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-over-specialization", "title": "Over-Specialization" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of runtime cost added by composing behavior from many small, indirected parts.", "term": "Definition", "wide": true }, { "description": "[Composability](/records/architecture/composability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with composability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-performance-overhead", "title": "Performance Overhead" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping an abstraction only where it separates parts that change for different reasons.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Over-Abstraction](/records/architecture/over-abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-preserve-only-real-boundaries", "title": "Preserve Only Real Boundaries" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to build a family of related products from shared, reusable components.", "term": "Definition", "wide": true }, { "description": "[Reusability](/records/architecture/reusability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reusability](/records/architecture/reusability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-product-lines", "title": "Product Lines" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for narrowing a module's public surface to the operations its consumers need.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Boundary Leakage](/records/architecture/boundary-leakage), [Inappropriate Intimacy](/records/architecture/inappropriate-intimacy), [Zombie Code](/records/architecture/zombie-code), [Explicit Boundaries](/records/architecture/explicit-boundaries), [Encapsulation](/records/architecture/encapsulation), [Information Hiding](/records/architecture/information-hiding), [Attack Surface Reduction](/records/architecture/attack-surface-reduction), [Risk Management](/records/architecture/risk-management), [Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-restrict-exports", "title": "Restrict Exports" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for forbidding writes to global objects outside one owning module.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Action at a Distance](/records/architecture/action-at-a-distance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-restrict-global-mutation", "title": "Restrict Global Mutation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for splitting an operation that both returns data and changes state into a query and a command.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-separate-query-from-command", "title": "Separate Query from Command" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to factor common functionality into libraries reused across projects.", "term": "Definition", "wide": true }, { "description": "[Reusability](/records/architecture/reusability)", "term": "Referenced by" }, { "description": "[Product Lines](/records/lexicon/product-lines): Shared libraries reuse common functionality across projects, while product lines build a family of related products from shared components.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reusability](/records/architecture/reusability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-libraries", "title": "Shared Libraries" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Coupling supposedly-independent modules through a shared runtime component they all depend on.", "term": "Definition", "wide": true }, { "description": "[Independence](/records/architecture/independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Independence](/records/architecture/independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-runtime-dependency", "title": "Shared Runtime Dependency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which composition adds wiring that inheritance would make simpler for trivial reuse.", "term": "Definition", "wide": true }, { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with composition-over-inheritance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-simplicity-for-trivial-reuse", "title": "Simplicity for Trivial Reuse" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which optimizing for one implementation undermines the ability to swap implementations.", "term": "Definition", "wide": true }, { "description": "[Interchangeability](/records/architecture/interchangeability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with interchangeability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-specialized-optimization", "title": "Specialized Optimization" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing an abstraction that grew flags for each caller into abstractions that fit one use each.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Premature Abstraction](/records/architecture/premature-abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-abstraction", "title": "Split Abstraction" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a catch-all module into modules named for the domain concepts they serve.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Utility Dump](/records/architecture/utility-dump)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-by-domain", "title": "Split by Domain" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a method that branches on a flag into one method per behavior.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Boolean Trap](/records/architecture/boolean-trap)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-method", "title": "Split Method" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a module into modules that each hold one reason to change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big Ball of Mud](/records/architecture/big-ball-of-mud), [Divergent Change](/records/architecture/divergent-change), [Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph), [High Cohesion](/records/architecture/high-cohesion), [Modularity](/records/architecture/modularity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-module", "title": "Split Module" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an abstraction's meaning stay consistent even as its implementations change.", "term": "Definition", "wide": true }, { "description": "[Abstraction](/records/architecture/abstraction)", "term": "Referenced by" }, { "description": "[Interface Definition](/records/lexicon/interface-definition): Stable semantics keeps an abstraction's meaning while implementations change, while an interface definition gives it a declared surface apart from its implementation.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Abstraction](/records/architecture/abstraction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-semantics", "title": "Stable Semantics" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to replace one interchangeable algorithm or implementation, such as a plugin at a declared seam, with another without modifying its host.", "term": "Definition", "wide": true }, { "description": "Plugin Swap", "term": "Aliases" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Interchangeability](/records/architecture/interchangeability)", "term": "Referenced by" }, { "description": "[Deferred Implementation Choice](/records/lexicon/deferred-implementation-choice): A strategy swap replaces one implementation with another, while deferred implementation choice postpones picking one until runtime.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Interchangeability](/records/architecture/interchangeability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strategy-swap", "title": "Strategy Swap" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Binding components so closely that a change in one forces changes in the others.", "term": "Definition", "wide": true }, { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Referenced by" }, { "description": "[Circular Dependency](/records/architecture/circular-dependency): Tight coupling is any binding that forces changes together, while a circular dependency is the particular case of a cycle.", "term": "Distinct from" }, { "description": "[Inappropriate Intimacy](/records/architecture/inappropriate-intimacy): Tight coupling is any binding that forces changes together, while inappropriate intimacy is the case of depending on another module's internals.", "term": "Distinct from" }, { "description": "[Message Chain](/records/architecture/message-chain): Tight coupling is any binding that forces changes together, while a message chain is the case of a client walking a chain of objects.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Low Coupling](/records/architecture/low-coupling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tight-coupling", "title": "Tight Coupling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to replace one vendor's implementation with another behind a stable interface.", "term": "Definition", "wide": true }, { "description": "[Replaceability](/records/architecture/replaceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Replaceability](/records/architecture/replaceability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vendor-swap", "title": "Vendor Swap" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Modular Design](/records/lexicon-category/core-modular-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "You Aren't Gonna Need It: build only what current requirements demand and defer speculative generality.", "term": "Definition", "wide": true }, { "description": "You Aren't Gonna Need It", "term": "Aliases" }, { "description": "[Reusability](/records/architecture/reusability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with reusability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-yagni", "title": "YAGNI" } ], "title": "Core Modular Design" }, { "icon": "bi-book", "id": "lexicon-category-core-vocabulary", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Predefined conditions a deliverable must satisfy to be accepted as complete and correct.", "term": "Definition", "wide": true }, { "description": "[Validation](/records/architecture/validation), [Model Evaluation](/records/architecture/model-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Validation](/records/architecture/validation), [Model Evaluation](/records/architecture/model-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-acceptance-criteria", "title": "Acceptance Criteria" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Identifiers whose meaning is unclear or open to multiple interpretations, obscuring intent.", "term": "Definition", "wide": true }, { "description": "[Semantic Contracts](/records/architecture/semantic-contracts), [Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Referenced by" }, { "description": "[Inconsistent Error Model](/records/architecture/inconsistent-error-model): Ambiguous naming is one identifier open to several readings, while an inconsistent error model is one failure reported in several shapes.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Semantic Contracts](/records/architecture/semantic-contracts), [Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ambiguous-naming", "title": "Ambiguous Naming" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Machine-applied checking that rules and policies hold, catching violations without manual review.", "term": "Definition", "wide": true }, { "description": "[Static Analysis](/records/architecture/static-analysis), [Policy as Code](/records/architecture/policy-as-code)", "term": "Referenced by" }, { "description": "[Policy as Code](/records/architecture/policy-as-code): Automated enforcement is any machine check that rules hold, while policy as code is writing the policies as the rules such a check evaluates.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Static Analysis](/records/architecture/static-analysis), [Architecture Review](/records/architecture/architecture-review), [Language-Oriented Programming](/records/architecture/language-oriented-programming), [Policy as Code](/records/architecture/policy-as-code), [Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-enforcement", "title": "Automated Enforcement" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The execution of tasks by software or machinery without manual intervention.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automation", "title": "Automation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Repetitive, mandatory scaffolding code that adds ceremony without domain value.", "term": "Definition", "wide": true }, { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern), [Builder Pattern](/records/architecture/builder-pattern), [Ports and Adapters Architecture](/records/architecture/ports-and-adapters-architecture), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Referenced by" }, { "description": "[Initial Complexity](/records/lexicon/initial-complexity): Boilerplate is scaffolding written again in every use, while initial complexity is the structure of ports and adapters paid once before the first feature.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with abstract-factory-pattern, the tension resolution with builder-pattern, the tension resolution with ports-and-adapters-architecture, the tension resolution with clean-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-boilerplate", "title": "Boilerplate" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Representing state through many interdependent boolean flags, producing tangled and invalid combinations.", "term": "Definition", "wide": true }, { "description": "[State Pattern](/records/architecture/state-pattern), [Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[State Pattern](/records/architecture/state-pattern), [Finite State Machine](/records/architecture/finite-state-machine)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-boolean-flag-soup", "title": "Boolean Flag Soup" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Forecasting resource demand and provisioning capacity to meet it without waste or shortfall.", "term": "Definition", "wide": true }, { "description": "[Capacity Planning](/records/algorithms/capacity-planning)", "term": "Contract" }, { "description": "[Resource Utilization](/records/architecture/resource-utilization), [Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resource Utilization](/records/architecture/resource-utilization), [Queuing Theory](/records/architecture/queuing-theory)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capacity-planning", "title": "Capacity Planning" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Producing source code automatically from a higher-level model, schema, or specification.", "term": "Definition", "wide": true }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design), [Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Contract-First Design](/records/architecture/contract-first-design), [Property-Based Testing](/records/architecture/property-based-testing), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Code as Data](/records/architecture/code-as-data), [Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-code-generation", "title": "Code Generation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component interoperates with other versions or systems without modification.", "term": "Definition", "wide": true }, { "description": "[Service Contract](/records/architecture/service-contract), [Schema Contract](/records/architecture/schema-contract), [Interoperability](/records/architecture/interoperability), [Robustness Principle](/records/architecture/robustness-principle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract), [Schema Contract](/records/architecture/schema-contract), [Interoperability](/records/architecture/interoperability), [Robustness Principle](/records/architecture/robustness-principle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility", "title": "Compatibility" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The single startup location where an application's object graph is assembled and its dependencies wired.", "term": "Definition", "wide": true }, { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Singleton Pattern](/records/architecture/singleton-pattern), [Inversion of Control (IoC)](/records/architecture/inversion-of-control), [Dependency Injection](/records/architecture/dependency-injection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-composition-root", "title": "Composition Root" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The surrounding information and circumstances captured to make a decision, event, or log entry interpretable.", "term": "Definition", "wide": true }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Logging](/records/architecture/logging)", "term": "Referenced by" }, { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records): Context is the surrounding information that makes a record interpretable, while a decision record is one record that carries it.", "term": "Distinct from" }, { "description": "[Consequences](/records/lexicon/consequences): Context is what surrounded a decision, while consequences are what follow from it.", "term": "Distinct from" }, { "description": "[Decision](/records/lexicon/decision): Context is the circumstances a choice was made in, while the decision is the choice.", "term": "Distinct from" }, { "description": "[Structured Events](/records/lexicon/structured-events): Context is the information attached to an entry, while structured events are entries written as machine-parsable records.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Logging](/records/architecture/logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context", "title": "Context" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Handling data incrementally as it arrives, rather than in discrete scheduled batches.", "term": "Definition", "wide": true }, { "description": "[Event Stream](/records/architecture/event-stream), [Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream), [Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuous-processing", "title": "Continuous Processing" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Explicit, enforceable agreements specifying the inputs, outputs, and guarantees between components.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability), [Decentralization](/records/architecture/decentralization), [Specification-Based Testing](/records/architecture/specification-based-testing), [Impact Analysis](/records/architecture/impact-analysis), [Capability Declaration](/records/architecture/capability-declaration), [Extension Points](/records/architecture/extension-points), [Type Safety](/records/architecture/type-safety), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Referenced by" }, { "description": "[Component Boundaries](/records/lexicon/component-boundaries): Contracts state the inputs, outputs and guarantees between components, while component boundaries are the edges those contracts sit on.", "term": "Distinct from" }, { "description": "[Standards](/records/lexicon/standards): Contracts are agreements between particular components, while standards are conventions that many components conform to.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interoperability](/records/architecture/interoperability), [Decentralization](/records/architecture/decentralization), [Specification-Based Testing](/records/architecture/specification-based-testing), [Impact Analysis](/records/architecture/impact-analysis), [Capability Declaration](/records/architecture/capability-declaration), [Extension Points](/records/architecture/extension-points), [Type Safety](/records/architecture/type-safety), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contracts", "title": "Contracts" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Mediated, restricted access to a resource so that only permitted operations reach it.", "term": "Definition", "wide": true }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern), [Authorization](/records/architecture/authorization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Proxy Pattern](/records/architecture/proxy-pattern), [Authorization](/records/architecture/authorization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-access", "title": "Controlled Access" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The managed, deliberate change of a system over time without breaking existing consumers.", "term": "Definition", "wide": true }, { "description": "[Versioning](/records/architecture/versioning), [Governance](/records/architecture/governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Versioning](/records/architecture/versioning), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-evolution", "title": "Controlled Evolution" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The resource or financial expenditure required to build, run, or change a system.", "term": "Definition", "wide": true }, { "description": "[Verification](/records/architecture/verification), [Environment Parity](/records/architecture/environment-parity), [Fault Tolerance](/records/architecture/fault-tolerance), [Redundancy](/records/architecture/redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with verification, the tension resolution with environment-parity, the tension resolution with fault-tolerance, the tension resolution with redundancy", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost", "title": "Cost" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Concerns such as logging, security, or transactions whose implementation spans many modules rather than localizing to one.", "term": "Definition", "wide": true }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Modularity](/records/architecture/modularity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with explicit-boundaries, the tension resolution with modularity", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-cutting-concerns", "title": "Cross-Cutting Concerns" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Containing the blast radius of a failure or breach so its impact stays bounded.", "term": "Definition", "wide": true }, { "description": "[Fail Safe](/records/architecture/fail-safe), [Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Safe](/records/architecture/fail-safe), [Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-damage-limitation", "title": "Damage Limitation" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of locating and diagnosing the cause of a defect.", "term": "Definition", "wide": true }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Reproducibility](/records/architecture/reproducibility), [Logging](/records/architecture/logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dynamic-binding, [Reproducibility](/records/architecture/reproducibility), [Logging](/records/architecture/logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-debugging", "title": "Debugging" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which changes are delivered to production.", "term": "Definition", "wide": true }, { "description": "[Correctness](/records/architecture/correctness), [Architecture Review](/records/architecture/architecture-review), [Threat Modeling](/records/architecture/threat-modeling), [Compliance](/records/architecture/compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with correctness, the tension resolution with architecture-review, the tension resolution with threat-modeling, the tension resolution with compliance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delivery-speed", "title": "Delivery Speed" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to locate available components, services, or capabilities at runtime.", "term": "Definition", "wide": true }, { "description": "[Introspection](/records/architecture/introspection), [Plugin Architecture](/records/architecture/plugin-architecture), [Service Registry](/records/architecture/service-registry), [Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" }, { "description": "[Diagnostics](/records/lexicon/diagnostics): Discovery locates which components are available, while diagnostics inspects a running system's structure and state to find what is wrong.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Introspection](/records/architecture/introspection), [Plugin Architecture](/records/architecture/plugin-architecture), [Service Registry](/records/architecture/service-registry), [Registry Pattern](/records/architecture/registry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-discovery", "title": "Discovery" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Domain-specific languages, small notations tailored to express solutions within one problem domain.", "term": "Definition", "wide": true }, { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Metaprogramming](/records/architecture/metaprogramming), [Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Metaprogramming](/records/architecture/metaprogramming), [Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dsls", "title": "DSLs" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The systematic assessment of a model or system's behavior and quality against defined criteria.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance), [Model Safety](/records/architecture/model-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Governance](/records/architecture/model-governance), [Model Safety](/records/architecture/model-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evaluation", "title": "Evaluation" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Recorded proof that substantiates a claim, decision, or compliance requirement.", "term": "Definition", "wide": true }, { "description": "[Assessment](/records/architecture/assessment), [Compliance](/records/architecture/compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Assessment](/records/architecture/assessment), [Compliance](/records/architecture/compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evidence", "title": "Evidence" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "All data a computation needs supplied through its parameters rather than read from ambient or hidden state.", "term": "Definition", "wide": true }, { "description": "[Pure Functions](/records/architecture/pure-functions), [Stateless Processing](/records/architecture/stateless-processing)", "term": "Referenced by" }, { "description": "[No Hidden State](/records/lexicon/no-hidden-state): Explicit inputs forbid reading ambient state during a call, while no hidden state forbids keeping state between calls.", "term": "Distinct from" }, { "description": "[No Side Effects](/records/lexicon/no-side-effects): Explicit inputs govern what a computation reads, while no side effects governs what it writes.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pure Functions](/records/architecture/pure-functions), [Stateless Processing](/records/architecture/stateless-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-inputs", "title": "Explicit Inputs" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "An alternative path or default invoked automatically when the primary operation fails or is unavailable.", "term": "Definition", "wide": true }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Degradation](/records/architecture/graceful-degradation), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fallback", "title": "Fallback" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Incorrect positive results reported when the detected condition is not present.", "term": "Definition", "wide": true }, { "description": "[Static Analysis](/records/architecture/static-analysis), [Health Checks](/records/architecture/health-checks), [Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with static-analysis, the tension resolution with health-checks, the tension resolution with policy-enforcement", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-false-positives", "title": "False Positives" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to release a component to production without coordinating the deployment of others.", "term": "Definition", "wide": true }, { "description": "[Service Contract](/records/architecture/service-contract), [Low Coupling](/records/architecture/low-coupling), [Independence](/records/architecture/independence), [Autonomy](/records/architecture/autonomy), [Microservices](/records/architecture/microservices)", "term": "Referenced by" }, { "description": "[Bounded Context Ownership](/records/lexicon/bounded-context-ownership): Independent deployment is releasing without coordinating others, while bounded context ownership is one team controlling one part of the system.", "term": "Distinct from" }, { "description": "[Independent Testing](/records/lexicon/independent-testing): Independent deployment is releasing a component alone, while independent testing is exercising it alone.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract), [Low Coupling](/records/architecture/low-coupling), [Independence](/records/architecture/independence), [Autonomy](/records/architecture/autonomy), [Microservices](/records/architecture/microservices)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-deployment", "title": "Independent Deployment" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Work partitioned into discrete units that execute in isolation, without shared mutable state or ordering dependencies.", "term": "Definition", "wide": true }, { "description": "[Parallelism](/records/architecture/parallelism), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parallelism](/records/architecture/parallelism), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-work-units", "title": "Independent Work Units" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which cycles of change and feedback can be completed.", "term": "Definition", "wide": true }, { "description": "[Contract-First Design](/records/architecture/contract-first-design), [Validation](/records/architecture/validation), [Design Review](/records/architecture/design-review)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with contract-first-design, the tension resolution with validation, the tension resolution with design-review", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-iteration-speed", "title": "Iteration Speed" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process inputs too large to fit in memory, through streaming or chunking.", "term": "Definition", "wide": true }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency), [Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Memory Efficiency](/records/architecture/memory-efficiency), [Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-large-input-handling", "title": "Large Input Handling" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Rejecting any state change that is not a permitted transition.", "term": "Definition", "wide": true }, { "description": "[State Pattern](/records/architecture/state-pattern), [Finite State Machine](/records/architecture/finite-state-machine)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[State Pattern](/records/architecture/state-pattern), [Finite State Machine](/records/architecture/finite-state-machine)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-legal-transition-enforcement", "title": "Legal-Transition Enforcement" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The agreed schema and semantics of messages exchanged between components.", "term": "Definition", "wide": true }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Message Queue](/records/architecture/message-queue), [Integration Events](/records/architecture/integration-events), [Asynchronous Communication](/records/architecture/asynchronous-communication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Message Queue](/records/architecture/message-queue), [Integration Events](/records/architecture/integration-events), [Asynchronous Communication](/records/architecture/asynchronous-communication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-message-contract", "title": "Message Contract" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about a system's structure, capabilities, or content, consumed to drive behavior.", "term": "Definition", "wide": true }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Describing API](/records/architecture/self-describing-api)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata", "title": "Metadata" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Quantitative measurements a system emits about its state and behavior for monitoring and analysis.", "term": "Definition", "wide": true }, { "description": "[Model Evaluation](/records/architecture/model-evaluation), [Observability](/records/architecture/observability), [Monitoring](/records/architecture/monitoring), [Elasticity](/records/architecture/elasticity), [Bottleneck Analysis](/records/architecture/bottleneck-analysis), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure), [Model Evaluation](/records/architecture/model-evaluation), [Observability](/records/architecture/observability), [Monitoring](/records/architecture/monitoring), [Elasticity](/records/architecture/elasticity), [Bottleneck Analysis](/records/architecture/bottleneck-analysis), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metrics", "title": "Metrics" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The gradual loss of a model's fidelity to the reality it represents, as data or conditions change over time.", "term": "Definition", "wide": true }, { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-drift", "title": "Model Drift" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing an unexplained literal with a named constant that states its meaning.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Magic Value](/records/architecture/magic-value)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-name-constant", "title": "Name Constant" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving a recurring group of values or steps a name in the domain language and one home in the code.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Data Clumps](/records/architecture/data-clumps), [Boolean Trap](/records/architecture/boolean-trap), [Magic Value](/records/architecture/magic-value), [Pattern Cargo Cult](/records/architecture/pattern-cargo-cult), [Utility Dump](/records/architecture/utility-dump), [Semantic Contracts](/records/architecture/semantic-contracts), [Domain Events](/records/architecture/domain-events), [Normalization](/records/architecture/normalization), [Semantic Consistency](/records/architecture/semantic-consistency), [Ubiquitous Language](/records/architecture/ubiquitous-language), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-name-the-concept", "title": "Name the Concept" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The effort and intricacy required to deploy, run, and maintain a system in production.", "term": "Definition", "wide": true }, { "description": "[Service Discovery](/records/architecture/service-discovery), [Secrets Management](/records/architecture/secrets-management), [Microservices](/records/architecture/microservices)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with service-discovery, the tension resolution with secrets-management, the tension resolution with microservices", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-complexity", "title": "Operational Complexity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A clear assignment of responsibility for a component to a person or team.", "term": "Definition", "wide": true }, { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Source of Truth](/records/architecture/single-source-of-truth), [State Isolation](/records/architecture/state-isolation)", "term": "Referenced by" }, { "description": "[Canonical Definition](/records/lexicon/canonical-definition): Ownership assigns responsibility for a component to a team, while a canonical definition gives a fact one authoritative definition.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explicit Boundaries](/records/architecture/explicit-boundaries), [Single Source of Truth](/records/architecture/single-source-of-truth), [State Isolation](/records/architecture/state-isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ownership", "title": "Ownership" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Independently-developed components that attach to a host at defined extension points to add capabilities.", "term": "Definition", "wide": true }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design), [Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design), [Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plugins", "title": "Plugins" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A declared set of rules governing what actions are permitted or denied within a system.", "term": "Definition", "wide": true }, { "description": "[Control Plane](/records/architecture/control-plane), [Authorization](/records/architecture/authorization), [Governance](/records/architecture/governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Control Plane](/records/architecture/control-plane), [Authorization](/records/architecture/authorization), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-policy", "title": "Policy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect where the outcome depends on the uncontrolled interleaving of concurrent operations.", "term": "Definition", "wide": true }, { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship), [Concurrency](/records/architecture/concurrency), [Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" }, { "description": "[Lost Update](/records/architecture/lost-update): A race condition is any outcome that depends on interleaving, while a lost update is the particular case of one writer overwriting another.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Happens-Before Relationship](/records/architecture/happens-before-relationship), [Concurrency](/records/architecture/concurrency), [Concurrency Control](/records/architecture/concurrency-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-race-conditions", "title": "Race Conditions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Restoring a system to correct operation or a consistent state after a failure.", "term": "Definition", "wide": true }, { "description": "[Resilience](/records/architecture/resilience), [Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resilience](/records/architecture/resilience), [Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-recovery", "title": "Recovery" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing a boolean parameter or flag with a closed set of named values.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Primitive Obsession](/records/architecture/primitive-obsession), [Stringly Typed Programming](/records/architecture/stringly-typed-programming), [Boolean Trap](/records/architecture/boolean-trap), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replace-boolean-with-enum", "title": "Replace Boolean with Enum" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to re-process a recorded sequence of events to reconstruct or recover state, including the state at a past point.", "term": "Definition", "wide": true }, { "description": "Historical Reconstruction", "term": "Aliases" }, { "description": "[Event Stream](/records/architecture/event-stream), [Event Sourcing](/records/architecture/event-sourcing), [Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" }, { "description": "[Temporal Queries](/records/lexicon/temporal-queries): Replay reprocesses recorded events to rebuild state, while a temporal query asks what the state was at a given point.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream), [Event Sourcing](/records/architecture/event-sourcing), [Append-Only Log](/records/architecture/append-only-log)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replay", "title": "Replay" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Using an existing component, module, or solution in a new context rather than rebuilding it.", "term": "Definition", "wide": true }, { "description": "[Standardization](/records/architecture/standardization), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standardization](/records/architecture/standardization), [Component-Based Architecture](/records/architecture/component-based-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reuse", "title": "Reuse" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Resolving a binding or call target at runtime through an intermediary layer rather than a direct, static reference.", "term": "Definition", "wide": true }, { "description": "[Low Coupling](/records/architecture/low-coupling), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with low-coupling, the tension resolution with dependency-inversion", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-indirection", "title": "Runtime Indirection" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Choosing default configurations and behaviors that are safe when left unchanged.", "term": "Definition", "wide": true }, { "description": "[Fail Safe](/records/architecture/fail-safe), [Secure by Default](/records/architecture/secure-by-default)", "term": "Referenced by" }, { "description": "[Fail Safe](/records/architecture/fail-safe): Safe defaults are the state shipped when nothing is changed, while fail safe is the state left behind when an operation fails.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Safe](/records/architecture/fail-safe), [Secure by Default](/records/architecture/secure-by-default)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-defaults", "title": "Safe Defaults" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Changing a system's internal structure with confidence that its observable behavior is preserved.", "term": "Definition", "wide": true }, { "description": "[Invariant](/records/architecture/invariant), [Predictability](/records/architecture/predictability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Invariant](/records/architecture/invariant), [Predictability](/records/architecture/predictability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-refactoring", "title": "Safe Refactoring" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Replacing a component or expression with an equivalent one without altering program correctness.", "term": "Definition", "wide": true }, { "description": "[Referential Transparency](/records/architecture/referential-transparency), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Referential Transparency](/records/architecture/referential-transparency), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-substitution", "title": "Safe Substitution" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the structure, types, and constraints of data.", "term": "Definition", "wide": true }, { "description": "[API Contract](/records/architecture/api-contract), [Data Contract](/records/architecture/data-contract), [Self-Describing Structures](/records/architecture/self-describing-structures), [Input Validation](/records/architecture/input-validation)", "term": "Referenced by" }, { "description": "[Schemas Tag](/records/lexicon/schemas-tag): A schema is the formal definition of data, while the schemas tag names the file concern that holds such definitions.", "term": "Distinct from" }, { "description": "[Type Metadata](/records/lexicon/type-metadata): A schema defines the structure data must take, while type metadata describes the field types a structure has at runtime.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[API Contract](/records/architecture/api-contract), [Data Contract](/records/architecture/data-contract), [Self-Describing Structures](/records/architecture/self-describing-structures), [Input Validation](/records/architecture/input-validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schema", "title": "Schema" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A failure that occurs without surfacing any error, log, or signal, leaving it undetected.", "term": "Definition", "wide": true }, { "description": "[Fail Fast](/records/architecture/fail-fast), [Logging](/records/architecture/logging), [Alerting](/records/architecture/alerting)", "term": "Referenced by" }, { "description": "[Log-as-Control-Flow](/records/architecture/log-as-control-flow): A silent failure leaves no signal at all, while log-as-control-flow leaves a log line and carries on as if it were handled.", "term": "Distinct from" }, { "description": "[Observability Noise](/records/architecture/observability-noise): A silent failure emits nothing, while observability noise emits too much to act on.", "term": "Distinct from" }, { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption): A silent failure is any unsurfaced failure, while silent data corruption is invalid data accepted and stored unchecked.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Fast](/records/architecture/fail-fast), [Error Handling](/records/architecture/error-handling), [Logging](/records/architecture/logging), [Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-silent-failure", "title": "Silent Failure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A component whose failure alone halts the entire system because it has no redundancy.", "term": "Definition", "wide": true }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Redundancy](/records/architecture/redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fault Tolerance](/records/architecture/fault-tolerance), [Redundancy](/records/architecture/redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-point-of-failure", "title": "Single Point of Failure" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A precise, authoritative description of required behavior, structure, or interface.", "term": "Definition", "wide": true }, { "description": "[Correctness](/records/architecture/correctness), [Specification-Based Testing](/records/architecture/specification-based-testing), [Verification](/records/architecture/verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correctness](/records/architecture/correctness), [Specification-Based Testing](/records/architecture/specification-based-testing), [Verification](/records/architecture/verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-specification", "title": "Specification" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Interfaces and agreements that remain unchanged over time so that consumers can depend on them safely.", "term": "Definition", "wide": true }, { "description": "[Uniform Interface](/records/architecture/uniform-interface), [Reusability](/records/architecture/reusability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Uniform Interface](/records/architecture/uniform-interface), [Reusability](/records/architecture/reusability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-contracts", "title": "Stable Contracts" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Agreed conventions and specifications that components conform to for interoperability and consistency.", "term": "Definition", "wide": true }, { "description": "[Interoperability](/records/architecture/interoperability), [Portability](/records/architecture/portability), [Governance](/records/architecture/governance)", "term": "Referenced by" }, { "description": "[Policy](/records/lexicon/policy): Standards are conventions components conform to, while a policy is rules on which actions are permitted or denied.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interoperability](/records/architecture/interoperability), [Portability](/records/architecture/portability), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-standards", "title": "Standards" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Configured boundary values that trigger an alert or action when a measured metric crosses them.", "term": "Definition", "wide": true }, { "description": "[Monitoring](/records/architecture/monitoring), [Alerting](/records/architecture/alerting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring), [Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-thresholds", "title": "Thresholds" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A bounded maximum amount of time allotted for an operation to complete.", "term": "Definition", "wide": true }, { "description": "[Timeout Pattern](/records/architecture/timeout-pattern), [Latency](/records/architecture/latency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Timeout Pattern](/records/architecture/timeout-pattern), [Latency](/records/architecture/latency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-time-budget", "title": "Time Budget" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The amount of time an activity requires, weighed as a cost against its benefit.", "term": "Definition", "wide": true }, { "description": "[Assessment](/records/architecture/assessment), [Gap Analysis](/records/architecture/gap-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with assessment, the tension resolution with gap-analysis", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-time-cost", "title": "Time Cost" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the types of a structure's fields, available for inspection at runtime.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures), [Introspection](/records/architecture/introspection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures), [Introspection](/records/architecture/introspection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-type-metadata", "title": "Type Metadata" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Core Vocabulary](/records/lexicon-category/core-vocabulary)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reverse a previously applied operation and to reapply it.", "term": "Definition", "wide": true }, { "description": "[Command Pattern](/records/architecture/command-pattern), [Memento Pattern](/records/architecture/memento-pattern)", "term": "Referenced by" }, { "description": "[Deferred Execution](/records/lexicon/deferred-execution): Undo and redo reverse and reapply an operation, while deferred execution runs a captured request later.", "term": "Distinct from" }, { "description": "[Snapshot/Restore](/records/lexicon/snapshot-restore): Undo reverses one operation, while snapshot and restore returns an object to a whole captured state.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Pattern](/records/architecture/command-pattern), [Memento Pattern](/records/architecture/memento-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-undo-redo", "title": "Undo/Redo" } ], "title": "Core Vocabulary" }, { "icon": "bi-book", "id": "lexicon-category-correctness-determinism-verification", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of extra memory allocation incurred by creating new immutable values instead of mutating in place.", "term": "Definition", "wide": true }, { "description": "[Immutability](/records/architecture/immutability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with immutability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-allocation-cost", "title": "Allocation Cost" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Shipping on untested assumptions about behavior instead of validating that requirements are met.", "term": "Definition", "wide": true }, { "description": "[Validation](/records/architecture/validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Validation](/records/architecture/validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assumption-driven-delivery", "title": "Assumption-Driven Delivery" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to confirm a system behaves as its specification requires.", "term": "Definition", "wide": true }, { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-behavior-validation", "title": "Behavior Validation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to exercise a function across a wide, generated range of inputs.", "term": "Definition", "wide": true }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-broad-input-exploration", "title": "Broad Input Exploration" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for testing one deployable component through its public interface with its dependencies replaced.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Test Pyramid Inversion](/records/architecture/test-pyramid-inversion), [Validation](/records/architecture/validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-component-tests", "title": "Component Tests" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which pinning everything for reproducibility conflicts with continuously updating dependencies.", "term": "Definition", "wide": true }, { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with reproducibility", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuous-updates", "title": "Continuous Updates" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that all inputs and state affecting a computation be fixed, bounded or fully specified, so its behavior is reproducible.", "term": "Definition", "wide": true }, { "description": "Controlled Inputs", "term": "Aliases" }, { "description": "[Determinism](/records/architecture/determinism), [Repeatability](/records/architecture/repeatability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Determinism](/records/architecture/determinism), [Repeatability](/records/architecture/repeatability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-state", "title": "Controlled State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of cost and complexity added by formally proving a system correct.", "term": "Definition", "wide": true }, { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with formal-verification", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-complexity", "title": "Cost/Complexity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the code under test produce the same result for the same inputs.", "term": "Definition", "wide": true }, { "description": "[Testability](/records/architecture/testability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Testability](/records/architecture/testability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deterministic-behavior", "title": "Deterministic Behavior" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which runtime-adaptive behavior undermines a system's predictability.", "term": "Definition", "wide": true }, { "description": "[Predictability](/records/architecture/predictability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with predictability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-runtime-behavior", "title": "Dynamic Runtime Behavior" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for placing a value's validation in the type that holds it, so every instance is valid.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Primitive Obsession](/records/architecture/primitive-obsession)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-encapsulate-validation", "title": "Encapsulate Validation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which hiding internals too strictly makes a unit's behavior hard to observe in tests.", "term": "Definition", "wide": true }, { "description": "[Testability](/records/architecture/testability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with testability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-encapsulation-extremes", "title": "Encapsulation Extremes" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Behavior that changes with the host environment, so the same run yields different results elsewhere.", "term": "Definition", "wide": true }, { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-environment-sensitive-behavior", "title": "Environment-Sensitive Behavior" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Testing only a few hand-picked examples instead of properties that must hold across all inputs.", "term": "Definition", "wide": true }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-example-only-testing", "title": "Example-Only Testing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing an external dependency in tests with a working in-memory implementation of its port.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mock Mirage](/records/architecture/mock-mirage), [Flaky Test Normalization](/records/architecture/flaky-test-normalization), [Repeatability](/records/architecture/repeatability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fake-at-the-boundary", "title": "Fake at the Boundary" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a product meets the needs of its users.", "term": "Definition", "wide": true }, { "description": "[Validation](/records/architecture/validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Validation](/records/architecture/validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fitness-for-use", "title": "Fitness for Use" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Depending on unpinned, floating dependency versions, so builds are not reproducible.", "term": "Definition", "wide": true }, { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Referenced by" }, { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization): Floating dependencies make builds unreproducible through unpinned versions, while flaky test normalization accepts intermittent failures by rerunning them.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-floating-dependencies", "title": "Floating Dependencies" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A precise, mathematical statement of what a system must do, against which it is proven.", "term": "Definition", "wide": true }, { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formal-specification", "title": "Formal Specification" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Behavior triggered by hidden state or side effects, so outcomes surprise callers.", "term": "Definition", "wide": true }, { "description": "[Predictability](/records/architecture/predictability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Predictability](/records/architecture/predictability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-behavior", "title": "Hidden Behavior" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Performing input/output inside a supposedly pure function, hiding side effects from callers.", "term": "Definition", "wide": true }, { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-io", "title": "Hidden IO" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Reading the clock, randomness, or global state inside a computation, making its output nondeterministic.", "term": "Definition", "wide": true }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Determinism](/records/architecture/determinism), [Referential Transparency](/records/architecture/referential-transparency), [Testability](/records/architecture/testability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-time-randomness-global-state", "title": "Hidden Time/Randomness/Global State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which static analysis findings are left unresolved until the analyzer's output stops being read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ignored-analyzer-findings", "title": "Ignored Analyzer Findings" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Testing only against the current implementation's behavior rather than the specified contract.", "term": "Definition", "wide": true }, { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Referenced by" }, { "description": "[Mock Mirage](/records/architecture/mock-mirage): Implementation-only testing checks today's behavior instead of the contract, while a mock mirage checks calls on mocks instead of behavior.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implementation-only-testing", "title": "Implementation-Only Testing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Relying only on informal checks and testing where a formal proof of correctness is warranted.", "term": "Definition", "wide": true }, { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-informal-validation-only", "title": "Informal Validation Only" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for supplying time and random values through parameters, so the code under test runs the same way every time.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization), [Determinism](/records/architecture/determinism)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inject-clock-and-randomness", "title": "Inject Clock and Randomness" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking after each change that the rules a state must always satisfy still hold.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption), [Design by Contract](/records/architecture/design-by-contract), [Postconditions](/records/architecture/postconditions), [Robustness Principle](/records/architecture/robustness-principle), [ACID](/records/architecture/acid), [Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invariant-check", "title": "Invariant Check" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving each test its own data and resources, so tests pass in any order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-isolate-test-state", "title": "Isolate Test State" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving input, output and mutation to named boundary operations, so the code between them stays pure.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hidden Side Effect](/records/architecture/hidden-side-effect), [Testability](/records/architecture/testability), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-make-effects-explicit", "title": "Make Effects Explicit" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to prove mathematically that a system meets its specification.", "term": "Definition", "wide": true }, { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Formal Verification](/records/architecture/formal-verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mathematical-assurance", "title": "Mathematical Assurance" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a function compute its result without observable side effects.", "term": "Definition", "wide": true }, { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-no-side-effects", "title": "No Side Effects" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for passing request, user or tenant context as a parameter or scoped object instead of reading it from global state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ambient Context](/records/architecture/ambient-context), [Reusability](/records/architecture/reusability), [Logging](/records/architecture/logging), [Stateless Processing](/records/architecture/stateless-processing), [State Isolation](/records/architecture/state-isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pass-context-explicitly", "title": "Pass Context Explicitly" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording exact versions of dependencies and tools, so every build uses the same inputs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pin-versions", "title": "Pin Versions" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking at the end of an operation that the result and state it promises hold.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Implicit Contract](/records/architecture/implicit-contract), [Design by Contract](/records/architecture/design-by-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-postcondition-check", "title": "Postcondition Check" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking at the start of an operation that the state and arguments it requires hold.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Implicit Contract](/records/architecture/implicit-contract), [Temporal Coupling](/records/architecture/temporal-coupling), [Exception Control Flow](/records/architecture/exception-control-flow), [Manual Runbook Dependency](/records/architecture/manual-runbook-dependency), [Design by Contract](/records/architecture/design-by-contract), [Preconditions](/records/architecture/preconditions), [Defensive Programming](/records/architecture/defensive-programming), [Fail Fast](/records/architecture/fail-fast)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-precondition-check", "title": "Precondition Check" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the general properties or invariants a function must satisfy be defined.", "term": "Definition", "wide": true }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-properties-invariants", "title": "Properties/Invariants" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which controlling conditions for repeatability diverges from real-world variability.", "term": "Definition", "wide": true }, { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with repeatability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-real-world-variability", "title": "Real-World Variability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to catch regressions when code changes by re-running tests.", "term": "Definition", "wide": true }, { "description": "[Testability](/records/architecture/testability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Testability](/records/architecture/testability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-regression-safety", "title": "Regression Safety" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to automate a process reliably because it repeats identically each run.", "term": "Definition", "wide": true }, { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Repeatability](/records/architecture/repeatability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-automation", "title": "Reliable Automation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to test dependably because the same inputs always produce the same outputs.", "term": "Definition", "wide": true }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Determinism](/records/architecture/determinism)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-testing", "title": "Reliable Testing" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The set of rules a static analyzer checks source code against.", "term": "Definition", "wide": true }, { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ruleset", "title": "Ruleset" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which making behavior deterministic limits adapting dynamically at runtime.", "term": "Definition", "wide": true }, { "description": "[Determinism](/records/architecture/determinism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with determinism", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-adaptivity", "title": "Runtime Adaptivity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to operate without producing incorrect or harmful results.", "term": "Definition", "wide": true }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correctness](/records/architecture/correctness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-operation", "title": "Safe Operation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to share data freely across threads because it cannot be modified.", "term": "Definition", "wide": true }, { "description": "[Immutability](/records/architecture/immutability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutability](/records/architecture/immutability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-sharing", "title": "Safe Sharing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which reducing a failing generated case to a minimal example adds debugging complexity.", "term": "Definition", "wide": true }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with property-based-testing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shrinking-debug-complexity", "title": "Shrinking/Debug Complexity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Producing observable side effects in an expression, so it cannot be replaced by its value.", "term": "Definition", "wide": true }, { "description": "[Referential Transparency](/records/architecture/referential-transparency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Referential Transparency](/records/architecture/referential-transparency), [Pure Functions](/records/architecture/pure-functions)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-side-effects", "title": "Side Effects" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of ongoing effort to keep a specification current as the system evolves.", "term": "Definition", "wide": true }, { "description": "[Specification-Based Testing](/records/architecture/specification-based-testing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with specification-based-testing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-spec-maintenance", "title": "Spec Maintenance" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to confirm an implementation conforms to its specification.", "term": "Definition", "wide": true }, { "description": "[Verification](/records/architecture/verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Verification](/records/architecture/verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-specification-compliance", "title": "Specification Compliance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which stateful input/output conflicts with expressions being replaceable by their values.", "term": "Definition", "wide": true }, { "description": "[Referential Transparency](/records/architecture/referential-transparency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with referential-transparency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stateful-io", "title": "Stateful IO" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which operations that depend on or mutate state conflict with purity.", "term": "Definition", "wide": true }, { "description": "[Pure Functions](/records/architecture/pure-functions)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pure-functions", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stateful-operations", "title": "Stateful Operations" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for asserting on a unit's outputs and effects instead of on the internal calls it makes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mock Mirage](/records/architecture/mock-mirage)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-test-observable-behavior", "title": "Test Observable Behavior" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Executable checks that assert a system behaves as intended.", "term": "Definition", "wide": true }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Referenced by" }, { "description": "[Specification](/records/lexicon/specification): Tests are executable checks, while a specification is the description of required behavior they check against.", "term": "Distinct from" }, { "description": "[Test Tag](/records/lexicon/test-tag): Tests are the executable checks, while the test marker names the file that holds one.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correctness](/records/architecture/correctness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tests", "title": "Tests" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which data can be accessed concurrently without corruption.", "term": "Definition", "wide": true }, { "description": "[Immutability](/records/architecture/immutability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutability](/records/architecture/immutability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-thread-safety", "title": "Thread Safety" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Running dynamically generated or evaluated code that static analysis cannot inspect for defects.", "term": "Definition", "wide": true }, { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Static Analysis](/records/architecture/static-analysis), [Code as Data](/records/architecture/code-as-data), [Metaprogramming](/records/architecture/metaprogramming), [Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unchecked-dynamic-code", "title": "Unchecked Dynamic Code" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Relying on operations whose result is unspecified, so outcomes vary unpredictably across runs or platforms.", "term": "Definition", "wide": true }, { "description": "[Correctness](/records/architecture/correctness)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correctness](/records/architecture/correctness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-undefined-behavior", "title": "Undefined Behavior" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for testing one unit of behavior in isolation, fast enough to run on every change.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Test Pyramid Inversion](/records/architecture/test-pyramid-inversion), [Correctness](/records/architecture/correctness), [Verification](/records/architecture/verification), [Impact Analysis](/records/architecture/impact-analysis), [Metaprogramming](/records/architecture/metaprogramming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unit-tests", "title": "Unit Tests" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "Shipping code with no tests, so its conformance to the specification is unverified.", "term": "Definition", "wide": true }, { "description": "[Verification](/records/architecture/verification)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Verification](/records/architecture/verification)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-untested-implementation", "title": "Untested Implementation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for validating fields that depend on each other together, in the object that groups them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Data Clumps](/records/architecture/data-clumps)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-validate-as-a-group", "title": "Validate as a Group" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for rejecting malformed input where it enters the system, so the core receives only valid values.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption), [Invariant](/records/architecture/invariant), [Validation](/records/architecture/validation), [Configuration Externalization](/records/architecture/configuration-externalization), [Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-validate-at-the-boundary", "title": "Validate at the Boundary" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that values be compared and copied by content rather than by reference identity.", "term": "Definition", "wide": true }, { "description": "[Immutability](/records/architecture/immutability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutability](/records/architecture/immutability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-value-semantics", "title": "Value Semantics" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Correctness / Determinism / Verification](/records/lexicon-category/correctness-determinism-verification)", "Layer: [Computation Core](/records/layer/computation-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that all inputs to a build or computation be pinned to specific versions.", "term": "Definition", "wide": true }, { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reproducibility](/records/architecture/reproducibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-versioned-inputs", "title": "Versioned Inputs" } ], "title": "Correctness / Determinism / Verification" }, { "icon": "bi-book", "id": "lexicon-category-creational-patterns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a prototype object support being copied to produce new instances.", "term": "Definition", "wide": true }, { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cloneable-template-object", "title": "Cloneable Template Object" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of complexity in assembling an object that motivates a step-by-step builder.", "term": "Definition", "wide": true }, { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complex-construction", "title": "Complex Construction" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Building elaborate parallel factory class hierarchies where cloning an existing configured instance would suffice.", "term": "Definition", "wide": true }, { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complex-factory-hierarchies", "title": "Complex Factory Hierarchies" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Instantiating concrete classes directly with constructors, coupling callers to specific implementations.", "term": "Definition", "wide": true }, { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concrete-constructor-coupling", "title": "Concrete Constructor Coupling" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having a constructor or factory accept only arguments that produce a valid object.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Temporal Coupling](/records/architecture/temporal-coupling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-constructor-valid-state", "title": "Constructor-Valid State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to govern how and when an object is created.", "term": "Definition", "wide": true }, { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-instantiation", "title": "Controlled Instantiation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of care required to define correct deep versus shallow copying when cloning objects.", "term": "Definition", "wide": true }, { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with prototype-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-copy-semantics", "title": "Copy Semantics" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A precondition that different variants of a product must be produced depending on runtime context.", "term": "Definition", "wide": true }, { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-creation-variation", "title": "Creation Variation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let subclasses decide which class to instantiate, deferring the choice from the base class.", "term": "Definition", "wide": true }, { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-instantiation", "title": "Deferred Instantiation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to create new objects at runtime by cloning existing configured instances.", "term": "Definition", "wide": true }, { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-object-creation", "title": "Dynamic Object Creation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to swap an entire family of related products by changing a single factory.", "term": "Definition", "wide": true }, { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-family-level-replacement", "title": "Family-Level Replacement" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Exposing global variables that any code can mutate, creating hidden coupling and nondeterminism.", "term": "Definition", "wide": true }, { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Singleton Pattern](/records/architecture/singleton-pattern), [State Isolation](/records/architecture/state-isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-mutable-state", "title": "Global Mutable State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which relying on subclassing to vary creation adds to the inheritance hierarchy's complexity.", "term": "Definition", "wide": true }, { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with factory-method-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inheritance-complexity", "title": "Inheritance Complexity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Combining products from different incompatible families, producing inconsistent sets of objects.", "term": "Definition", "wide": true }, { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mixed-product-families", "title": "Mixed Product Families" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to create objects through a common interface without naming their concrete classes.", "term": "Definition", "wide": true }, { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-polymorphic-construction", "title": "Polymorphic Construction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that products form families of related variants meant to be used together.", "term": "Definition", "wide": true }, { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Abstract Factory Pattern](/records/architecture/abstract-factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-related-product-variants", "title": "Related Product Variants" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which each new object repeats a costly setup that copying a prepared instance would avoid.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prototype Pattern](/records/architecture/prototype-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repeated-expensive-setup", "title": "Repeated Expensive Setup" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Spreading object-creation logic across many call sites instead of centralizing it in a factory.", "term": "Definition", "wide": true }, { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Pattern](/records/architecture/factory-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scattered-construction-logic", "title": "Scattered Construction Logic" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to give many callers coordinated access to one shared resource.", "term": "Definition", "wide": true }, { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-resource-access", "title": "Shared Resource Access" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A precondition that exactly one instance of a type must exist across the system.", "term": "Definition", "wide": true }, { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Singleton Pattern](/records/architecture/singleton-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-instance-need", "title": "Single-Instance Need" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that subclasses determine which concrete product a creator instantiates.", "term": "Definition", "wide": true }, { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Factory Method Pattern](/records/architecture/factory-method-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subclass-controlled-creation", "title": "Subclass-Controlled Creation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Overloading constructors with ever more parameters to cover optional fields, producing unreadable call sites.", "term": "Definition", "wide": true }, { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-telescoping-constructor", "title": "Telescoping Constructor" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Creational Patterns](/records/lexicon-category/creational-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to construct an object only once all its required parts are supplied and validated.", "term": "Definition", "wide": true }, { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Builder Pattern](/records/architecture/builder-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-valid-object-creation", "title": "Valid Object Creation" } ], "title": "Creational Patterns" }, { "icon": "bi-book", "id": "lexicon-category-domain-architecture", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for enforcing a rule across related entities inside the aggregate that owns them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anemic Domain Model](/records/architecture/anemic-domain-model), [Aggregate](/records/architecture/aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-add-aggregate-invariant", "title": "Add Aggregate Invariant" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enlarging an aggregate to enforce invariants increases contention and load on it.", "term": "Definition", "wide": true }, { "description": "[Aggregate](/records/architecture/aggregate)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with aggregate", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-aggregate-size", "title": "Aggregate Size" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "Implementing business logic as procedural scripts over data-only objects, with no rich domain model.", "term": "Definition", "wide": true }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anemic-transaction-script", "title": "Anemic Transaction Script" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which two entities are judged to be the same by comparing their attributes instead of their identity.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Entity](/records/architecture/entity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-attribute-compared-identity", "title": "Attribute-Compared Identity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep business rules inside the domain objects they govern.", "term": "Definition", "wide": true }, { "description": "[Domain Model](/records/architecture/domain-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain Model](/records/architecture/domain-model)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-business-rule-encapsulation", "title": "Business Rule Encapsulation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which isolating each context's model limits reusing models across contexts.", "term": "Definition", "wide": true }, { "description": "[Bounded Context](/records/architecture/bounded-context)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with bounded-context", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-context-reuse", "title": "Cross-Context Reuse" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to place logic that spans several entities in a dedicated domain service.", "term": "Definition", "wide": true }, { "description": "[Domain Service](/records/architecture/domain-service)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain Service](/records/architecture/domain-service)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-entity-domain-logic", "title": "Cross-Entity Domain Logic" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree of ongoing effort to document and maintain the map of relationships between contexts.", "term": "Definition", "wide": true }, { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with context-mapping", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-documentation-overhead", "title": "Documentation Overhead" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep the software model closely aligned with the business domain it serves.", "term": "Definition", "wide": true }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-alignment", "title": "Domain Alignment" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the domain model stays free of external and infrastructure concerns.", "term": "Definition", "wide": true }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-purity", "title": "Domain Purity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a clear boundary separate the domain from external systems it integrates with.", "term": "Definition", "wide": true }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-boundary", "title": "Explicit Boundary" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for turning procedural steps over data into domain types that hold their own rules.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Transaction Script Sprawl](/records/architecture/transaction-script-sprawl), [Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-domain-model", "title": "Extract Domain Model" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving read-only, use-case-specific queries out of a repository into a query service.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Repository Dump](/records/architecture/repository-dump)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-query-service", "title": "Extract Query Service" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving one business operation into an application service that coordinates the domain and its ports.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Envy](/records/architecture/feature-envy), [Transaction Script Sprawl](/records/architecture/transaction-script-sprawl), [Fat Controller](/records/architecture/fat-controller)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-use-case", "title": "Extract Use Case" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to treat two objects as the same when they share an identity, regardless of their attributes.", "term": "Definition", "wide": true }, { "description": "[Entity](/records/architecture/entity)", "term": "Referenced by" }, { "description": "[Lifecycle Tracking](/records/lexicon/lifecycle-tracking): Identity-based equality compares two objects by identity, while lifecycle tracking follows one object through its changes.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Entity](/records/architecture/entity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-based-equality", "title": "Identity-Based Equality" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "Integrating contexts through undocumented, assumed connections instead of explicit, mapped relationships.", "term": "Definition", "wide": true }, { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implicit-integration", "title": "Implicit Integration" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which relationships between contexts are made explicit and understandable.", "term": "Definition", "wide": true }, { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-integration-clarity", "title": "Integration Clarity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to integrate a legacy or external system without letting its model corrupt the domain.", "term": "Definition", "wide": true }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-legacy-system-integration", "title": "Legacy/System Integration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to track an entity as the same thing through changes over its lifetime.", "term": "Definition", "wide": true }, { "description": "[Entity](/records/architecture/entity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Entity](/records/architecture/entity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lifecycle-tracking", "title": "Lifecycle Tracking" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for translating external or persistence data into domain types at the boundary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fat Controller](/records/architecture/fat-controller), [Framework Leakage](/records/architecture/framework-leakage)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-map-to-domain-model", "title": "Map to Domain Model" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving business rules out of controllers, services and scripts into the domain objects they govern.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Envy](/records/architecture/feature-envy), [Anemic Domain Model](/records/architecture/anemic-domain-model), [Transaction Script Sprawl](/records/architecture/transaction-script-sprawl), [Fat Controller](/records/architecture/fat-controller), [Repository Dump](/records/architecture/repository-dump), [Domain Model](/records/architecture/domain-model), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-logic-to-the-domain", "title": "Move Logic to the Domain" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which modeling many concepts as distinct value objects increases the number of objects.", "term": "Definition", "wide": true }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with value-object", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-object-count", "title": "Object Count" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a rich domain model complicates straightforward mapping to storage.", "term": "Definition", "wide": true }, { "description": "[Domain Model](/records/architecture/domain-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with domain-model", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-persistence-simplicity", "title": "Persistence Simplicity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a domain object can be put into a state that breaks its own rules.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Invariant](/records/architecture/invariant), [Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reachable-invalid-state", "title": "Reachable Invalid State" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each relationship between bounded contexts carry a defined meaning.", "term": "Definition", "wide": true }, { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Context Mapping](/records/architecture/context-mapping)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-relationship-semantics", "title": "Relationship Semantics" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to enforce an aggregate's invariants by routing all changes through its root.", "term": "Definition", "wide": true }, { "description": "[Aggregate](/records/architecture/aggregate)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Aggregate](/records/architecture/aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-root-guarded-invariants", "title": "Root-Guarded Invariants" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability for a value object to guarantee its own validity at construction.", "term": "Definition", "wide": true }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" }, { "description": "[Side-Effect-Free Equality](/records/lexicon/side-effect-free-equality): Self-validating values guarantee validity at construction, while side-effect-free equality compares values by content.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Value Object](/records/architecture/value-object)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-self-validating-values", "title": "Self-Validating Values" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "Forcing one global model across the whole system, so unrelated parts are coupled through it.", "term": "Definition", "wide": true }, { "description": "[Bounded Context](/records/architecture/bounded-context)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bounded Context](/records/architecture/bounded-context)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-global-model", "title": "Shared Global Model" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to compare value objects by their contents with no side effects.", "term": "Definition", "wide": true }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Value Object](/records/architecture/value-object)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-side-effect-free-equality", "title": "Side-Effect-Free Equality" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a full domain model adds overhead where simple create-read-update-delete would suffice.", "term": "Definition", "wide": true }, { "description": "[Domain-Driven Design (DDD)](/records/architecture/domain-driven-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with domain-driven-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-simple-crud", "title": "Simple CRUD" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a model that serves several meanings into contexts that each own one meaning of their terms.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Monolith](/records/architecture/distributed-monolith), [Domain-Driven Design (DDD)](/records/architecture/domain-driven-design), [Bounded Context](/records/architecture/bounded-context), [Semantic Contracts](/records/architecture/semantic-contracts), [Single Responsibility Principle (SRP)](/records/architecture/single-responsibility), [Independence](/records/architecture/independence), [Autonomy](/records/architecture/autonomy), [Semantic Consistency](/records/architecture/semantic-consistency), [Microservices](/records/architecture/microservices)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-bounded-context", "title": "Split Bounded Context" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A technique for reducing a repository to persistence of one aggregate and moving everything else out of it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Repository Dump](/records/architecture/repository-dump)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-repository", "title": "Split Repository" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an entity keep one stable identifier throughout its lifetime.", "term": "Definition", "wide": true }, { "description": "[Entity](/records/architecture/entity), [Declared Subject](/records/architecture/declared-subject), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Entity](/records/architecture/entity), [Declared Subject](/records/architecture/declared-subject), [Reversible Channel Encoding](/records/architecture/reversible-channel-encoding), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-identity", "title": "Stable Identity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The ability to treat an aggregate as the unit within which invariants hold atomically.", "term": "Definition", "wide": true }, { "description": "[Aggregate](/records/architecture/aggregate)", "term": "Referenced by" }, { "description": "[Root-Guarded Invariants](/records/lexicon/root-guarded-invariants): The consistency boundary is the unit within which invariants hold atomically, while root-guarded invariants are enforced by routing every change through the root.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Aggregate](/records/architecture/aggregate)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transactional-consistency-boundary", "title": "Transactional Consistency Boundary" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "A mapping between an external system's concepts and the domain's own, keeping the two vocabularies separate.", "term": "Definition", "wide": true }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-translation-model", "title": "Translation Model" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Domain Architecture](/records/lexicon-category/domain-architecture)", "Layer: [Domain Modeling](/records/layer/domain-modeling)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that two value objects be treated as equal when all their attributes match.", "term": "Definition", "wide": true }, { "description": "[Value Object](/records/architecture/value-object)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Value Object](/records/architecture/value-object)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-value-equality", "title": "Value Equality" } ], "title": "Domain Architecture" }, { "icon": "bi-book", "id": "lexicon-category-domain-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a recognized milestone and the condition that grants it, filed in an achievements folder.", "term": "Definition", "wide": true }, { "description": "achievements/first-win.achievement.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-achievement-tag", "title": "Achievement Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a cluster of domain objects changed together through one root, filed in an aggregates folder.", "term": "Definition", "wide": true }, { "description": "aggregates/cart.aggregate.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-aggregate-tag", "title": "Aggregate Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds data temporarily between a producer and a consumer, filed in a buffers folder.", "term": "Definition", "wide": true }, { "description": "buffers/audio.buffer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-buffer-tag", "title": "Buffer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that records a point a long process can resume from, filed in a checkpoints folder.", "term": "Definition", "wide": true }, { "description": "checkpoints/import.checkpoint.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-checkpoint-tag", "title": "Checkpoint Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a grouped set of domain members and the operations over the set, filed in a collections folder.", "term": "Definition", "wide": true }, { "description": "collections/playlist.collection.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-collection-tag", "title": "Collection Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares a limit a domain value or operation must stay within, filed in a constraints folder.", "term": "Definition", "wide": true }, { "description": "constraints/quantity.constraint.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-constraint-tag", "title": "Constraint Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a unit of value participants earn and spend, filed in a currencies folder.", "term": "Definition", "wide": true }, { "description": "currencies/gold.currency.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-currency-tag", "title": "Currency Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines something meaningful that happened in the domain, filed in a domain-events folder.", "term": "Definition", "wide": true }, { "description": "domain-events/order-placed.domain-event.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-event-tag", "title": "Domain-Event Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the weighted outcomes a source can yield, filed in a drop-tables folder.", "term": "Definition", "wide": true }, { "description": "drop-tables/goblin.drop-table.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-drop-table-tag", "title": "Drop-Table Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a domain object with an identity that persists while its attributes change, filed in an entities folder.", "term": "Definition", "wide": true }, { "description": "entities/customer.entity.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-entity-tag", "title": "Entity Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the wrapper carrying a payload's routing and metadata, filed in an envelopes folder.", "term": "Definition", "wide": true }, { "description": "envelopes/message.envelope.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-envelope-tag", "title": "Envelope Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a notification of something that happened, filed in an events folder.", "term": "Definition", "wide": true }, { "description": "events/payment.event.ts", "term": "Example" }, { "description": "[Events](/records/lexicon/events): Events are the records of what happened, while the event tag names the file concern that defines one.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Events](/records/lexicon/events)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-tag", "title": "Event Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that states a property the domain must keep true across every change, filed in an invariants folder.", "term": "Definition", "wide": true }, { "description": "invariants/balance.invariant.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invariant-tag", "title": "Invariant Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines what a participant holds and the rules for adding and removing it, filed in an inventories folder.", "term": "Definition", "wide": true }, { "description": "inventories/backpack.inventory.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inventory-tag", "title": "Inventory Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one kind of object a participant can own or use, filed in an items folder.", "term": "Definition", "wide": true }, { "description": "items/sword.item.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-item-tag", "title": "Item Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one stage of a world a simulation or game advances through, filed in a levels folder.", "term": "Definition", "wide": true }, { "description": "levels/forest.level.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-level-tag", "title": "Level Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a conceptual representation of what the system is about, filed in a models folder.", "term": "Definition", "wide": true }, { "description": "models/order.model.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-tag", "title": "Model Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the body a message or request carries, filed in a payloads folder.", "term": "Definition", "wide": true }, { "description": "payloads/signup.payload.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-payload-tag", "title": "Payload Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines an object placed in a world that grants something when collected, filed in a pickups folder.", "term": "Definition", "wide": true }, { "description": "pickups/health.pickup.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pickup-tag", "title": "Pickup Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that chooses among admissible behaviors by a stated rule, filed in a policies folder.", "term": "Definition", "wide": true }, { "description": "policies/refund.policy.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Policy](/records/lexicon/policy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-policy-tag", "title": "Policy Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines how a participant advances through unlocks and thresholds, filed in a progression folder.", "term": "Definition", "wide": true }, { "description": "progression/player.progression.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-progression-tag", "title": "Progression Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that derives a read model from a stream of events, filed in a projections folder.", "term": "Definition", "wide": true }, { "description": "projections/sales.projection.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-projection-tag", "title": "Projection Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one objective with its conditions and its reward, filed in a quests folder.", "term": "Definition", "wide": true }, { "description": "quests/rescue.quest.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quest-tag", "title": "Quest Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one structured entry of data with named fields, filed in a records folder.", "term": "Definition", "wide": true }, { "description": "records/shipment.record.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-record-tag", "title": "Record Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines an addressable piece of data the system exposes or consumes, filed in a resources folder.", "term": "Definition", "wide": true }, { "description": "resources/product.resource.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-tag", "title": "Resource Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines what a participant receives for completing something, filed in a rewards folder.", "term": "Definition", "wide": true }, { "description": "rewards/daily-login.reward.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reward-tag", "title": "Reward Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds one business or governance rule as a unit, filed in a rules folder.", "term": "Definition", "wide": true }, { "description": "rules/discount.rule.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rule-tag", "title": "Rule Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines an exchange of currency for items with its stock and prices, filed in a shops folder.", "term": "Definition", "wide": true }, { "description": "shops/blacksmith.shop.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shop-tag", "title": "Shop Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one ability a participant can train and use, filed in a skills folder.", "term": "Definition", "wide": true }, { "description": "skills/archery.skill.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-skill-tag", "title": "Skill Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that captures the state of something at one moment so it can be read or restored later, filed in a snapshots folder.", "term": "Definition", "wide": true }, { "description": "snapshots/editor.snapshot.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-snapshot-tag", "title": "Snapshot Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares a required end state or a selection rule as data other code evaluates, filed in a specifications folder.", "term": "Definition", "wide": true }, { "description": "specifications/overdue-invoice.specification.ts", "term": "Example" }, { "description": "[Behavior Tag](/records/lexicon/behavior-tag): A specification only declares a required state or rule as data, while a behavior decides what an agent does next.", "term": "Distinct from" }, { "description": "[Specification](/records/lexicon/specification): A specification is the description of required behavior, while the specification tag names the file concern that declares one as data.", "term": "Distinct from" }, { "description": "[Template Tag](/records/lexicon/template-tag): A specification declares a rule other code evaluates, while a template declares a shape whose slots are filled.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Specification](/records/lexicon/specification)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-specification-tag", "title": "Specification Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries one interaction the system offers from its trigger to its outcome, filed in a use-cases folder.", "term": "Definition", "wide": true }, { "description": "use-cases/checkout.use-case.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Use Cases](/records/lexicon/use-cases)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-use-case-tag", "title": "Use-Case Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a domain value compared by its contents rather than by an identity, filed in a value-objects folder.", "term": "Definition", "wide": true }, { "description": "value-objects/money.value-object.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-value-object-tag", "title": "Value-Object Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Domain Concerns](/records/lexicon-category/domain-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one timed group of arrivals within a level, filed in a waves folder.", "term": "Definition", "wide": true }, { "description": "waves/boss.wave.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-wave-tag", "title": "Wave Tag" } ], "title": "Domain Concerns" }, { "icon": "bi-book", "id": "lexicon-category-error-handling-resilience", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Failing the entire system when one part fails instead of degrading to reduced but working service.", "term": "Definition", "wide": true }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-all-or-nothing-failure", "title": "All-Or-Nothing Failure" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a defined alternate behavior exist to use when the primary path fails.", "term": "Definition", "wide": true }, { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alternate-behavior", "title": "Alternate Behavior" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which tripping a breaker to protect the system also cuts off a still-partly-working dependency.", "term": "Definition", "wide": true }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with circuit-breaker-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-availability-of-degraded-dependency", "title": "Availability of Degraded Dependency" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Progressively increasing the wait between retries to avoid overwhelming a recovering dependency.", "term": "Definition", "wide": true }, { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Storm](/records/architecture/retry-storm), [Retry Pattern](/records/architecture/retry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-backoff", "title": "Backoff" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to contain a failure so it affects only one isolated partition.", "term": "Definition", "wide": true }, { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blast-radius-reduction", "title": "Blast-Radius Reduction" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving a queue a fixed capacity, so producers are slowed or refused instead of exhausting memory.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Missing Backpressure](/records/architecture/missing-backpressure), [Backpressure](/records/architecture/backpressure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-queue", "title": "Bounded Queue" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for retrying a failed call a limited number of times with growing delays before giving up.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Storm](/records/architecture/retry-storm), [Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-retry", "title": "Bounded Retry" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to guarantee an operation waits no longer than a set limit.", "term": "Definition", "wide": true }, { "description": "[Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-waiting", "title": "Bounded Waiting" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A fragile design that breaks entirely under any condition it was not explicitly built for.", "term": "Definition", "wide": true }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resilience](/records/architecture/resilience)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-brittle-architecture", "title": "Brittle Architecture" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for letting a caller stop work it no longer needs, releasing the resources that work holds.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Timeout Omission](/records/architecture/timeout-omission)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cancellation", "title": "Cancellation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that downstream capacity be signaled upstream so producers adjust their rate.", "term": "Definition", "wide": true }, { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capacity-signaling", "title": "Capacity Signaling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to stop one component's failure from cascading through its callers.", "term": "Definition", "wide": true }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cascading-failure-prevention", "title": "Cascading Failure Prevention" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which serving reduced functionality during failure sacrifices full consistency or completeness.", "term": "Definition", "wide": true }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with graceful-degradation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-feature-completeness", "title": "Consistency / Feature Completeness" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep operating correctly despite the failure of some components.", "term": "Definition", "wide": true }, { "description": "[Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fault Tolerance](/records/architecture/fault-tolerance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continued-operation-under-failure", "title": "Continued Operation Under Failure" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to fail in a defined, handled way rather than crashing unpredictably.", "term": "Definition", "wide": true }, { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-failure", "title": "Controlled Failure" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Timeout Omission](/records/architecture/timeout-omission), [Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deadline-propagation", "title": "Deadline Propagation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to default to denying access when a security check cannot complete.", "term": "Definition", "wide": true }, { "description": "[Fail Secure](/records/architecture/fail-secure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Secure](/records/architecture/fail-secure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deny-by-default-behavior", "title": "Deny-by-Default Behavior" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to surface a defect immediately at its source rather than letting it propagate.", "term": "Definition", "wide": true }, { "description": "[Fail Fast](/records/architecture/fail-fast)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Fast](/records/architecture/fail-fast)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-early-defect-detection", "title": "Early Defect Detection" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A structured representation of the kinds of errors a system can raise and how they are categorized.", "term": "Definition", "wide": true }, { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-model", "title": "Error Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Catching an exception and silently discarding it, hiding the failure from callers and logs.", "term": "Definition", "wide": true }, { "description": "[Error Handling](/records/architecture/error-handling)", "term": "Referenced by" }, { "description": "[Exception Control Flow](/records/architecture/exception-control-flow): Exception swallowing discards a real failure, while exception control flow uses exceptions for cases that are not failures.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Fast](/records/architecture/fail-fast), [Error Handling](/records/architecture/error-handling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exception-swallowing", "title": "Exception Swallowing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deciding per failure whether to stop with an error at once or to continue on a declared fallback.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Timeout Omission](/records/architecture/timeout-omission), [Log-as-Control-Flow](/records/architecture/log-as-control-flow), [Fail Fast](/records/architecture/fail-fast), [Fail Safe](/records/architecture/fail-safe)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fail-fast-or-fall-back", "title": "Fail Fast or Fall Back" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Granting access or continuing when a security check fails, exposing the system on error.", "term": "Definition", "wide": true }, { "description": "[Fail Secure](/records/architecture/fail-secure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Secure](/records/architecture/fail-secure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fail-open", "title": "Fail Open" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a failure be contained within a boundary so it cannot spread.", "term": "Definition", "wide": true }, { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-isolation", "title": "Failure Isolation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting a failure spread unchecked across component boundaries instead of containing it.", "term": "Definition", "wide": true }, { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resilience](/records/architecture/resilience), [Error Boundaries](/records/architecture/error-boundaries), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-propagation", "title": "Failure Propagation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement of a defined failure count or rate at which a circuit breaker trips.", "term": "Definition", "wide": true }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-threshold", "title": "Failure Threshold" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that individual features be isolated so one can be disabled without taking down others.", "term": "Definition", "wide": true }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Degradation](/records/architecture/graceful-degradation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-isolation", "title": "Feature Isolation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Parsing input so rigidly that any minor deviation causes a failure.", "term": "Definition", "wide": true }, { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fragile-parsing", "title": "Fragile Parsing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which catching failures at a boundary can obscure the underlying errors from view.", "term": "Definition", "wide": true }, { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with error-boundaries", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-errors", "title": "Hidden Errors" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for tagging each request with a unique key, so a repeated request is recognized and applied once.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Storm](/records/architecture/retry-storm), [Retry Pattern](/records/architecture/retry-pattern), [Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-idempotency-key", "title": "Idempotency Key" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for returning success or a typed error as a value, so callers handle failure through the type system.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Inconsistent Error Model](/records/architecture/inconsistent-error-model), [Exception Control Flow](/records/architecture/exception-control-flow), [Null Semantics Drift](/records/architecture/null-semantics-drift), [Log-as-Control-Flow](/records/architecture/log-as-control-flow), [Postconditions](/records/architecture/postconditions), [Error Handling](/records/architecture/error-handling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-typed-result", "title": "Introduce Typed Result" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding a random offset to retry delays, so clients that failed together do not retry together.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Storm](/records/architecture/retry-storm)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-jitter", "title": "Jitter" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which retrying failed operations multiplies load on an already-struggling dependency.", "term": "Definition", "wide": true }, { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with retry-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-load-amplification", "title": "Load Amplification" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for refusing part of the incoming work when load passes capacity, so the work already accepted completes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Missing Backpressure](/records/architecture/missing-backpressure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-load-shedding", "title": "Load Shedding" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to recover from a failure within its boundary without restarting the whole system.", "term": "Definition", "wide": true }, { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Error Boundaries](/records/architecture/error-boundaries)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-localized-recovery", "title": "Localized Recovery" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "An operation whose repetition changes the result, making it unsafe to retry.", "term": "Definition", "wide": true }, { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture), [Retry Pattern](/records/architecture/retry-pattern), [Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-non-idempotent-operation", "title": "Non-Idempotent Operation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to protect a system from being overwhelmed by shedding or slowing incoming load.", "term": "Definition", "wide": true }, { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-overload-protection", "title": "Overload Protection" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that resources be partitioned so exhaustion in one pool cannot starve others.", "term": "Definition", "wide": true }, { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-isolation", "title": "Resource Isolation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to fail without corrupting state or causing further damage.", "term": "Definition", "wide": true }, { "description": "[Defensive Programming](/records/architecture/defensive-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Defensive Programming](/records/architecture/defensive-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-failure", "title": "Safe Failure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Serving all work from one shared resource pool, so one overloaded consumer starves the rest.", "term": "Definition", "wide": true }, { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-resource-pool", "title": "Shared Resource Pool" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Providing only one execution path with no fallback, so any failure in it fails the whole request.", "term": "Definition", "wide": true }, { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-behavior-path", "title": "Single Behavior Path" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing timeouts sacrifices tolerance for legitimately slow operations.", "term": "Definition", "wide": true }, { "description": "[Timeout Pattern](/records/architecture/timeout-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with timeout-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-slow-operation-tolerance", "title": "Slow Operation Tolerance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system keeps operating steadily without collapsing under load.", "term": "Definition", "wide": true }, { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backpressure](/records/architecture/backpressure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stability", "title": "Stability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep functioning under load spikes and adverse conditions.", "term": "Definition", "wide": true }, { "description": "[Resilience](/records/architecture/resilience)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resilience](/records/architecture/resilience)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stability-under-stress", "title": "Stability Under Stress" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which serving a fallback yields stale or reduced-quality results.", "term": "Definition", "wide": true }, { "description": "[Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with fallback-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stale-reduced-results", "title": "Stale/Reduced Results" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a component emit only strictly conformant, well-formed output.", "term": "Definition", "wide": true }, { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Referenced by" }, { "description": "[Tolerant Input](/records/lexicon/tolerant-input): Strict output governs what a component emits, while tolerant input governs what it accepts.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strict-output", "title": "Strict Output" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which rejecting deviant input conflicts with accepting it tolerantly.", "term": "Definition", "wide": true }, { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with robustness-principle", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strict-validation", "title": "Strict Validation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an operation be given a maximum time to complete before being abandoned.", "term": "Definition", "wide": true }, { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timeout", "title": "Timeout" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a component accept and cope with input that deviates from the ideal format.", "term": "Definition", "wide": true }, { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Robustness Principle](/records/architecture/robustness-principle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tolerant-input", "title": "Tolerant Input" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to recover from short-lived failures by retrying the operation.", "term": "Definition", "wide": true }, { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Pattern](/records/architecture/retry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transient-failure-recovery", "title": "Transient Failure Recovery" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for converting vendor and infrastructure errors into the core's own error types where they enter.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vendor Lock-In Leakage](/records/architecture/vendor-lock-in-leakage)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-translate-errors-at-the-boundary", "title": "Translate Errors at the Boundary" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming inputs are valid and using them without checking, so bad data flows through unguarded.", "term": "Definition", "wide": true }, { "description": "[Defensive Programming](/records/architecture/defensive-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Design by Contract](/records/architecture/design-by-contract), [Preconditions](/records/architecture/preconditions), [Defensive Programming](/records/architecture/defensive-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trusting-invalid-inputs", "title": "Trusting Invalid Inputs" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Retrying a failing operation endlessly with no limit, amplifying load and delaying recovery.", "term": "Definition", "wide": true }, { "description": "[Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Referenced by" }, { "description": "[Retry Storm](/records/architecture/retry-storm): Unbounded retry is one caller retrying with no limit, while a retry storm is many callers whose combined retries prolong the failure, bounded or not.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retry Pattern](/records/architecture/retry-pattern), [Circuit Breaker Pattern](/records/architecture/circuit-breaker-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-retry", "title": "Unbounded Retry" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Continuing in an unsafe default state after a failure instead of stopping in a safe one.", "term": "Definition", "wide": true }, { "description": "[Fail Safe](/records/architecture/fail-safe)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Safe](/records/architecture/fail-safe)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unsafe-default-continuation", "title": "Unsafe Default Continuation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Error Handling / Resilience](/records/lexicon-category/error-handling-resilience)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which pervasive defensive checks add verbosity and clutter to the code.", "term": "Definition", "wide": true }, { "description": "[Defensive Programming](/records/architecture/defensive-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with defensive-programming", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-verbosity", "title": "Verbosity" } ], "title": "Error Handling / Resilience" }, { "icon": "bi-book", "id": "lexicon-category-event-messaging-async", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to handle work without blocking the caller, decoupling request from completion.", "term": "Definition", "wide": true }, { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-asynchronous-processing", "title": "Asynchronous Processing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a message is guaranteed to be delivered at least once, tolerating duplicates.", "term": "Definition", "wide": true }, { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-at-least-once-delivery-safety", "title": "At-Least-Once Delivery Safety" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to commit a state change and publish its corresponding message as one atomic unit.", "term": "Definition", "wide": true }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-atomic-state-change-message-publish", "title": "Atomic State Change + Message Publish" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A runtime intermediary that routes messages between publishers and subscribers.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-broker-event-bus", "title": "Broker/Event Bus" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of domain intricacy that a coordination mechanism must accommodate.", "term": "Definition", "wide": true }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with compensating-transaction", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-business-complexity", "title": "Business Complexity" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Separating operations that change state from those that return data, so each method has a single purpose.", "term": "Definition", "wide": true }, { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-command-query-separation", "title": "Command/Query Separation" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that receives and processes messages from a queue or topic.", "term": "Definition", "wide": true }, { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer", "title": "Consumer" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add or remove consumers dynamically to match message volume.", "term": "Definition", "wide": true }, { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-elasticity", "title": "Consumer Elasticity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for independent services to exchange information without direct coupling.", "term": "Definition", "wide": true }, { "description": "[Integration Events](/records/architecture/integration-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Integration Events](/records/architecture/integration-events)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-service-communication", "title": "Cross-Service Communication" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Persisting only current state via create-read-update-delete, discarding the history that event sourcing preserves.", "term": "Definition", "wide": true }, { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-crud-only-state-persistence", "title": "CRUD-Only State Persistence" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for domain logic to react to events without the emitter knowing its consumers.", "term": "Definition", "wide": true }, { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decoupled-domain-reactions", "title": "Decoupled Domain Reactions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to distribute events to many consumers without the source depending on any of them.", "term": "Definition", "wide": true }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decoupled-event-distribution", "title": "Decoupled Event Distribution" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A stable identifier attached to a message that lets a consumer detect and drop duplicates.", "term": "Definition", "wide": true }, { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deduplication-key", "title": "Deduplication Key" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which messages are delivered in a defined order, which broad fan-out can weaken.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with publish-subscribe-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delivery-ordering", "title": "Delivery Ordering" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Invoking event handlers by direct method call, coupling emitter to handler and defeating the event bus.", "term": "Definition", "wide": true }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-event-handler-calls", "title": "Direct Event Handler Calls" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Wiring services together with direct point-to-point calls, coupling each sender to specific receivers.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Message Broker](/records/architecture/message-broker)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-point-to-point-calls", "title": "Direct Point-to-Point Calls" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for distributed nodes to operate and decide independently without central coordination.", "term": "Definition", "wide": true }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-autonomy", "title": "Distributed Autonomy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Reprocessing a message so its side effects run more than once, corrupting state when not idempotent.", "term": "Definition", "wide": true }, { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer), [Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicate-side-effects", "title": "Duplicate Side Effects" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of overlap between integration events and domain events that must be kept in sync.", "term": "Definition", "wide": true }, { "description": "[Integration Events](/records/architecture/integration-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with integration-events", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplication-with-domain-events", "title": "Duplication with Domain Events" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The agreed schema and semantics of an event that publishers and subscribers both honor.", "term": "Definition", "wide": true }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-contract", "title": "Event Contract" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of coarseness or fineness at which events are defined, trading detail against volume.", "term": "Definition", "wide": true }, { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with domain-events", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-granularity", "title": "Event Granularity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which events are guaranteed to be delivered despite failures.", "term": "Definition", "wide": true }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-reliability", "title": "Event Reliability" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the structure and fields of an event's payload.", "term": "Definition", "wide": true }, { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-schema", "title": "Event Schema" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The agreed meaning of what an event represents and the conditions under which it is emitted.", "term": "Definition", "wide": true }, { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-semantics", "title": "Event Semantics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a high volume of events makes end-to-end flows hard to trace.", "term": "Definition", "wide": true }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with event-bus", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-storm-traceability", "title": "Event Storm / Traceability" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Records of things that have happened in a system, emitted for other components to react to.", "term": "Definition", "wide": true }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-events", "title": "Events" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to restore correct operation after a failure through compensation or retry.", "term": "Definition", "wide": true }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-recovery", "title": "Failure Recovery" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deliver one event to many interested subscribers at once.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fan-out-notification", "title": "Fan-Out Notification" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Attempting a single ACID transaction spanning multiple distributed services, creating tight coupling and availability loss.", "term": "Definition", "wide": true }, { "description": "[Saga Pattern](/records/architecture/saga-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Eventual Consistency](/records/architecture/eventual-consistency), [Saga Pattern](/records/architecture/saga-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-acid-transaction", "title": "Global ACID Transaction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which all nodes reflect the same state at once, which service autonomy gives up.", "term": "Definition", "wide": true }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with autonomy", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-consistency", "title": "Global Consistency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "An undocumented ordering requirement between operations that must run in a specific sequence to work correctly.", "term": "Definition", "wide": true }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-temporal-coupling", "title": "Hidden Temporal Coupling" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a read reflects the latest write instantly, which asynchronous processing defers.", "term": "Definition", "wide": true }, { "description": "[Asynchronous Communication](/records/architecture/asynchronous-communication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with asynchronous-communication", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-immediate-consistency", "title": "Immediate Consistency" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that recorded events never change once written, only be appended to.", "term": "Definition", "wide": true }, { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-immutable-events", "title": "Immutable Events" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Calling a component directly in-process where a durable queue is needed, losing buffering and delivery guarantees.", "term": "Definition", "wide": true }, { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Queue](/records/architecture/message-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-in-memory-direct-invocation", "title": "In-Memory Direct Invocation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Overwriting existing records in place where an append-only log is required, destroying history.", "term": "Definition", "wide": true }, { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-in-place-mutation", "title": "In-Place Mutation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Endlessly redelivering a failing message with no dead-letter path, blocking the queue indefinitely.", "term": "Definition", "wide": true }, { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-infinite-redelivery-loop", "title": "Infinite Redelivery Loop" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Leaking infrastructure or technical events into the domain model, polluting it with concerns it should not hold.", "term": "Definition", "wide": true }, { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain Events](/records/architecture/domain-events)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-infrastructure-events-in-domain", "title": "Infrastructure Events in Domain" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Exposing internal domain events to external consumers, coupling them to private model details.", "term": "Definition", "wide": true }, { "description": "[Integration Events](/records/architecture/integration-events)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Integration Events](/records/architecture/integration-events)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-internal-domain-event-leakage", "title": "Internal Domain Event Leakage" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing a synchronous call that need not complete in the request with an event a consumer handles later.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap), [Scalability](/records/architecture/scalability), [Latency](/records/architecture/latency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-async-event", "title": "Introduce Async Event" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Performing side effects that cannot be undone within a workflow that may need to roll back.", "term": "Definition", "wide": true }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-irreversible-side-effects", "title": "Irreversible Side Effects" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A transaction confined to a single service's own datastore, the atomic unit a saga or outbox composes.", "term": "Definition", "wide": true }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-transaction", "title": "Local Transaction" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to carry a business transaction across many steps and a long duration via compensation.", "term": "Definition", "wide": true }, { "description": "[Saga Pattern](/records/architecture/saga-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Saga Pattern](/records/architecture/saga-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-long-running-transactions", "title": "Long-Running Transactions" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that reads pending messages from an outbox and publishes them to the broker.", "term": "Definition", "wide": true }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-message-relay", "title": "Message Relay" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Keeping only mutable current state with no event record, so past states and changes cannot be recovered.", "term": "Definition", "wide": true }, { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mutable-state-only", "title": "Mutable State Only" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which consumed events cannot be read again, so a consumer cannot rebuild its state or recover from a fault.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-non-replayable-processing", "title": "Non-Replayable Processing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording how far each consumer has read in a stream, so it resumes there and can replay from earlier.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-offset-tracking", "title": "Offset Tracking" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system's operation depends on a message broker remaining available.", "term": "Definition", "wide": true }, { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with message-broker", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-dependency", "title": "Operational Dependency" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "An append-only sequence of records that preserves the order in which they were written.", "term": "Definition", "wide": true }, { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Referenced by" }, { "description": "[Event Schema](/records/lexicon/event-schema): An ordered log keeps records in write order, while an event schema defines what each record holds.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordered-log", "title": "Ordered Log" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each service alone own and control its data store.", "term": "Definition", "wide": true }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-own-data", "title": "Own Data" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving each service its own store and letting others reach the data only through its contract.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Monolith](/records/architecture/distributed-monolith), [Autonomy](/records/architecture/autonomy), [Microservices](/records/architecture/microservices)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-own-data-per-service", "title": "Own Data per Service" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for multiple consumers to process messages from the same source at once.", "term": "Definition", "wide": true }, { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Referenced by" }, { "description": "[Consumer Elasticity](/records/lexicon/consumer-elasticity): Parallel message processing is several consumers working at once, while consumer elasticity is changing how many there are to match volume.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-message-processing", "title": "Parallel Message Processing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Coupling a sender directly to a specific receiver, so adding a consumer requires changing the sender.", "term": "Definition", "wide": true }, { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern), [Message Broker](/records/architecture/message-broker)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-point-to-point-coupling", "title": "Point-to-Point Coupling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to divert a repeatedly-failing message to a separate queue so it stops blocking others.", "term": "Definition", "wide": true }, { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Referenced by" }, { "description": "[Reprocessing After Fix](/records/lexicon/reprocessing-after-fix): Quarantine moves a failing message aside, while reprocessing after the fix sends it through again.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-poison-message-quarantine", "title": "Poison-Message Quarantine" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that emits messages to a topic or bus for subscribers to receive.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" }, { "description": "[Broker/Event Bus](/records/lexicon/broker-event-bus): A publisher emits messages, while the broker routes them between publishers and subscribers.", "term": "Distinct from" }, { "description": "[Subscriber](/records/lexicon/subscriber): A publisher sends to a topic, while a subscriber receives from it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-publisher", "title": "Publisher" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of difficulty of answering queries when state is stored as an event history rather than current rows.", "term": "Definition", "wide": true }, { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with event-sourcing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-query-complexity", "title": "Query Complexity" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for maintaining a read model shaped for one query, updated from the writes it depends on.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Synchronous Chain Trap](/records/architecture/synchronous-chain-trap), [Chatty Interface](/records/architecture/chatty-interface), [N Plus One Query](/records/architecture/n-plus-one-query), [Event Sourcing](/records/architecture/event-sourcing), [Asynchronous Communication](/records/architecture/asynchronous-communication), [Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-query-projection", "title": "Query Projection" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to shape read and write models independently for their differing access patterns.", "term": "Definition", "wide": true }, { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-write-model-optimization", "title": "Read/Write Model Optimization" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of detecting and resolving divergence between replicas so they converge to a consistent state.", "term": "Definition", "wide": true }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reconciliation", "title": "Reconciliation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of added complexity of running a relay process that forwards messages from an outbox.", "term": "Definition", "wide": true }, { "description": "[Outbox Pattern](/records/architecture/outbox-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with outbox-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-relay-complexity", "title": "Relay Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reprocess quarantined messages once the underlying defect is fixed.", "term": "Definition", "wide": true }, { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reprocessing-after-fix", "title": "Reprocessing After Fix" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each step in a distributed workflow can be undone by a compensating action.", "term": "Definition", "wide": true }, { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compensating Transaction](/records/architecture/compensating-transaction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reversible-compensable-step", "title": "Reversible/Compensable Step" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to direct each message to its correct destination based on topic, key, or rule.", "term": "Definition", "wide": true }, { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-routing", "title": "Routing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to redeliver a message without causing duplicate effects, given idempotent handling.", "term": "Definition", "wide": true }, { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-message-redelivery", "title": "Safe Message Redelivery" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Multiple services reading and writing one shared database, coupling them and destroying service autonomy.", "term": "Definition", "wide": true }, { "description": "[Autonomy](/records/architecture/autonomy)", "term": "Referenced by" }, { "description": "[Cyclic Deployment Dependency](/records/architecture/cyclic-deployment-dependency): A shared database couples services through their data, while a cyclic deployment dependency couples them through their release order.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Independence](/records/architecture/independence), [Autonomy](/records/architecture/autonomy), [Microservices](/records/architecture/microservices)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-database", "title": "Shared Database" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Processing a queue with one consumer in series, so throughput cannot scale with load.", "term": "Definition", "wide": true }, { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Competing Consumers](/records/architecture/competing-consumers)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-serial-consumer", "title": "Single Serial Consumer" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for periodically storing a snapshot of state derived from a log, so readers replay only the events after it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-snapshot-compaction", "title": "Snapshot Compaction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of extra state a consumer must retain to deduplicate or order messages.", "term": "Definition", "wide": true }, { "description": "[Idempotent Consumer](/records/architecture/idempotent-consumer)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with idempotent-consumer", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-overhead", "title": "State Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which an append-only log's storage footprint grows unbounded over time.", "term": "Definition", "wide": true }, { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with append-only-log", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-storage-growth", "title": "Storage Growth" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which retaining a full event stream consumes large amounts of storage.", "term": "Definition", "wide": true }, { "description": "[Event Stream](/records/architecture/event-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with event-stream", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-storage-volume", "title": "Storage Volume" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which all reads see the latest write, which event-driven asynchrony relaxes.", "term": "Definition", "wide": true }, { "description": "[Event-Driven Architecture](/records/architecture/event-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with event-driven-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-consistency", "title": "Strong Consistency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which every read reflects the most recent write without delay, which eventual consistency relaxes.", "term": "Definition", "wide": true }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with eventual-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-immediate-consistency", "title": "Strong Immediate Consistency" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that registers interest in a topic and receives its messages.", "term": "Definition", "wide": true }, { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Referenced by" }, { "description": "[Broker/Event Bus](/records/lexicon/broker-event-bus): A subscriber receives a topic's messages, while the broker routes them to it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Publish/Subscribe Pattern](/records/architecture/publish-subscribe-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subscriber", "title": "Subscriber" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of which consumers subscribe to which topics and how they receive messages.", "term": "Definition", "wide": true }, { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Bus](/records/architecture/event-bus)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subscriber-model", "title": "Subscriber Model" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to model how state evolved over time by preserving each change as an event.", "term": "Definition", "wide": true }, { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Event Sourcing](/records/architecture/event-sourcing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-temporal-modeling", "title": "Temporal Modeling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to ask what a system's state was at any past point in time.", "term": "Definition", "wide": true }, { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Append-Only Log](/records/architecture/append-only-log)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-temporal-queries", "title": "Temporal Queries" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Using one shared model for both reads and writes, preventing each from being optimized for its purpose.", "term": "Definition", "wide": true }, { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Command Query Responsibility Segregation (CQRS)](/records/architecture/command-query-responsibility-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unified-crud-model", "title": "Unified CRUD Model" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The behavior users assume a system will exhibit, such as seeing their own writes immediately.", "term": "Definition", "wide": true }, { "description": "[Eventual Consistency](/records/architecture/eventual-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with eventual-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-user-expectations", "title": "User Expectations" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to spread units of work across many workers via a broker.", "term": "Definition", "wide": true }, { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Message Broker](/records/architecture/message-broker)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-work-distribution", "title": "Work Distribution" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Event Messaging Async](/records/lexicon-category/event-messaging-async)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of intricacy of coordinating a multi-step distributed workflow.", "term": "Definition", "wide": true }, { "description": "[Saga Pattern](/records/architecture/saga-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with saga-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-workflow-complexity", "title": "Workflow Complexity" } ], "title": "Event Messaging Async" }, { "icon": "bi-book", "id": "lexicon-category-infrastructure-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a general base others specialize, filed in an abstractions folder.", "term": "Definition", "wide": true }, { "description": "abstractions/shape.abstraction.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-abstraction-tag", "title": "Abstraction Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one named operation a caller can request, with its inputs, filed in an actions folder.", "term": "Definition", "wide": true }, { "description": "actions/add-to-cart.action.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-action-tag", "title": "Action Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that translates between the system's interface and an outside one, filed in an adapters folder.", "term": "Definition", "wide": true }, { "description": "adapters/payment-gateway.adapter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Adapters](/records/lexicon/adapters)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-adapter-tag", "title": "Adapter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that gives a second name to an existing type or value, filed in an aliases folder.", "term": "Definition", "wide": true }, { "description": "aliases/user-id.alias.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alias-tag", "title": "Alias Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines markers attached to code for tools to read, filed in an annotations folder.", "term": "Definition", "wide": true }, { "description": "annotations/serialization-hint.annotation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-annotation-tag", "title": "Annotation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that locates and describes a static resource the product serves, filed in an assets folder.", "term": "Definition", "wide": true }, { "description": "assets/logo.asset.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-asset-tag", "title": "Asset Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that groups many small operations into fewer larger ones, filed in a batching folder.", "term": "Definition", "wide": true }, { "description": "batching/analytics.batching.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-batching-tag", "title": "Batching Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that ties an abstract name to the concrete value or implementation it resolves to, filed in a bindings folder.", "term": "Definition", "wide": true }, { "description": "bindings/logger.binding.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-binding-tag", "title": "Binding Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that marks where one module's responsibility ends and checks what crosses it, filed in a boundaries folder.", "term": "Definition", "wide": true }, { "description": "boundaries/billing.boundary.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-boundary-tag", "title": "Boundary Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that assembles a complex object or a build output step by step, filed in a builders folder.", "term": "Definition", "wide": true }, { "description": "builders/query.builder.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-builder-tag", "title": "Builder Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries messages between publishers and subscribers who never refer to each other, filed in a buses folder.", "term": "Definition", "wide": true }, { "description": "buses/message.bus.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bus-tag", "title": "Bus Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that keeps computed or fetched values so a repeated request is answered without the original work, filed in a caches folder.", "term": "Definition", "wide": true }, { "description": "caches/thumbnail.cache.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cache-tag", "title": "Cache Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that derives the key a cached value is stored and found under, filed in a cache-keys folder.", "term": "Definition", "wide": true }, { "description": "cache-keys/product.cache-key.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cache-key-tag", "title": "Cache-Key Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides whether two versions or environments can work together, filed in a compatibility folder.", "term": "Definition", "wide": true }, { "description": "compatibility/api-version.compatibility.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility-tag", "title": "Compatibility Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that presents an old interface on top of a new implementation, filed in a compatibility-layers folder.", "term": "Definition", "wide": true }, { "description": "compatibility-layers/legacy-auth.compatibility-layer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility-layer-tag", "title": "Compatibility-Layer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that patches one small difference between environments so shared code runs on both, filed in a compatibility-shims folder.", "term": "Definition", "wide": true }, { "description": "compatibility-shims/fetch.compatibility-shim.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compatibility-shim-tag", "title": "Compatibility-Shim Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that treats a tree of parts and a single part through one interface, filed in a composites folder.", "term": "Definition", "wide": true }, { "description": "composites/menu.composite.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-composite-tag", "title": "Composite Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that encodes data into fewer bytes and restores it, filed in a compression folder.", "term": "Definition", "wide": true }, { "description": "compression/log.compression.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compression-tag", "title": "Compression Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the mass tag for a file that holds the settings a unit reads at start, singular in both folder and tag.", "term": "Definition", "wide": true }, { "description": "config/app.config.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-config-tag", "title": "Config Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that declares named values fixed at build time, plural in both folder and tag, which also holds id tables.", "term": "Definition", "wide": true }, { "description": "constants/http-status.constants.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-constants-tag", "title": "Constants Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that states what one side of a boundary guarantees to the other, filed in a contracts folder.", "term": "Definition", "wide": true }, { "description": "contracts/checkout-api.contract.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Contracts](/records/lexicon/contracts)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contract-tag", "title": "Contract Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that adds behavior to an object behind the object's own interface, filed in a decorators folder.", "term": "Definition", "wide": true }, { "description": "decorators/fetch-retry.decorator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decorator-tag", "title": "Decorator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies the values used where a caller sets none, filed in a defaults folder.", "term": "Definition", "wide": true }, { "description": "defaults/pagination.default.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-default-tag", "title": "Default Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that receives work another object hands on instead of doing it itself, filed in a delegates folder.", "term": "Definition", "wide": true }, { "description": "delegates/table-view.delegate.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delegate-tag", "title": "Delegate Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares and resolves the versions of the packages a unit depends on, filed in a dependency-management folder.", "term": "Definition", "wide": true }, { "description": "dependency-management/workspace.dependency-management.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dependency-management-tag", "title": "Dependency-Management Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that marks a surface as scheduled for removal and reports its uses, filed in a deprecations folder.", "term": "Definition", "wide": true }, { "description": "deprecations/v1-endpoint.deprecation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deprecation-tag", "title": "Deprecation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that describes one registrable thing in the shape its registry expects, filed in a descriptors folder.", "term": "Definition", "wide": true }, { "description": "descriptors/widget.descriptor.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-descriptor-tag", "title": "Descriptor Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one address a service answers and the request it accepts, filed in an endpoints folder.", "term": "Definition", "wide": true }, { "description": "endpoints/order-creation.endpoint.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-endpoint-tag", "title": "Endpoint Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that declares closed sets of named values, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "enums/color.enums.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-enums-tag", "title": "Enums Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that reads and validates the values that differ between deployments, filed in an environments folder.", "term": "Definition", "wide": true }, { "description": "environments/production.environment.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-environment-tag", "title": "Environment Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that chooses which entries a full cache drops, filed in an eviction folder.", "term": "Definition", "wide": true }, { "description": "eviction/session.eviction.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-eviction-tag", "title": "Eviction Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that ends an entry's life after a stated condition or time, filed in an expiration folder.", "term": "Definition", "wide": true }, { "description": "expiration/token.expiration.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-expiration-tag", "title": "Expiration Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that adds a capability to a host through the host's declared extension point, filed in an extensions folder.", "term": "Definition", "wide": true }, { "description": "extensions/markdown.extension.ts", "term": "Example" }, { "description": "[Plugin Tag](/records/lexicon/plugin-tag): An extension plugs into a host's declared extension point, while a plugin is discovered and loaded by the host.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extension-tag", "title": "Extension Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that offers one simple entry to a group of more complex parts, filed in a facades folder.", "term": "Definition", "wide": true }, { "description": "facades/media-library.facade.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-facade-tag", "title": "Facade Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that constructs instances so callers never call a constructor directly, filed in a factories folder.", "term": "Definition", "wide": true }, { "description": "factories/connection.factory.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-factory-tag", "title": "Factory Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that turns one feature on or off for a stated audience without a deploy, filed in a feature-flags folder.", "term": "Definition", "wide": true }, { "description": "feature-flags/new-checkout.feature-flag.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-flag-tag", "title": "Feature-Flag Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a boolean switch read at run time, filed in a flags folder.", "term": "Definition", "wide": true }, { "description": "flags/debug.flag.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flag-tag", "title": "Flag Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares a typeface and how it loads, filed in a fonts folder.", "term": "Definition", "wide": true }, { "description": "fonts/body-text.font.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-font-tag", "title": "Font Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that narrows a value's type after proving what it is, filed in a guards folder.", "term": "Definition", "wide": true }, { "description": "guards/email.guard.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guard-tag", "title": "Guard Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs when a host reaches one named point in its flow, filed in a hooks folder.", "term": "Definition", "wide": true }, { "description": "hooks/upload.hook.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hook-tag", "title": "Hook Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that declares the icons a product uses, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "icons/toolbar.icons.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-icons-tag", "title": "Icons Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that creates or validates the identifiers records are addressed by, filed in an identifiers folder.", "term": "Definition", "wide": true }, { "description": "identifiers/order-number.identifier.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identifier-tag", "title": "Identifier Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies a component's dependencies from outside it, filed in an injectors folder.", "term": "Definition", "wide": true }, { "description": "injectors/app.injector.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-injector-tag", "title": "Injector Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares the operations a type offers without implementing them, filed in an interfaces folder.", "term": "Definition", "wide": true }, { "description": "interfaces/printer.interface.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interface-tag", "title": "Interface Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides when a cached value no longer holds and removes it, filed in an invalidation folder.", "term": "Definition", "wide": true }, { "description": "invalidation/price.invalidation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Cache Invalidation](/records/lexicon/cache-invalidation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invalidation-tag", "title": "Invalidation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that disables a capability immediately when it misbehaves, filed in a kill-switches folder.", "term": "Definition", "wide": true }, { "description": "kill-switches/payments.kill-switch.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-kill-switch-tag", "title": "Kill-Switch Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one tier of a layered structure and what it may depend on, filed in a layers folder.", "term": "Definition", "wide": true }, { "description": "layers/data-access.layer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layer-tag", "title": "Layer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defers loading a part until the first time it is used, filed in a lazy-loading folder.", "term": "Definition", "wide": true }, { "description": "lazy-loading/image.lazy-loading.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lazy-loading-tag", "title": "Lazy-Loading Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that reads a resource from storage or the network into memory, filed in a loaders folder.", "term": "Definition", "wide": true }, { "description": "loaders/texture.loader.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-loader-tag", "title": "Loader Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that finds where a service or a resource lives, filed in a locators folder.", "term": "Definition", "wide": true }, { "description": "locators/printer.locator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-locator-tag", "title": "Locator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares what a unit contains or provides for a loader to read, filed in a manifests folder.", "term": "Definition", "wide": true }, { "description": "manifests/theme.manifest.ts", "term": "Example" }, { "description": "[Manifest](/records/lexicon/manifest): A manifest is the declarative document, while the manifest tag names the file concern that holds one.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Manifest](/records/lexicon/manifest)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manifest-tag", "title": "Manifest Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that remembers a function's results by its arguments, filed in a memoization folder.", "term": "Definition", "wide": true }, { "description": "memoization/tax-rate.memoization.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-memoization-tag", "title": "Memoization Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds data describing other data or code, filed in a metadata folder.", "term": "Definition", "wide": true }, { "description": "metadata/column.metadata.ts", "term": "Example" }, { "description": "[Metadata](/records/lexicon/metadata): Metadata is the descriptive data, while the metadata tag names the file concern that holds it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Metadata](/records/lexicon/metadata)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-tag", "title": "Metadata Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that moves stored data or a schema from one version to the next, filed in a migrations folder.", "term": "Definition", "wide": true }, { "description": "migrations/email-index.migration.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-migration-tag", "title": "Migration Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies reusable members many types can include, filed in a mixins folder.", "term": "Definition", "wide": true }, { "description": "mixins/serialization.mixin.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mixin-tag", "title": "Mixin Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares a self-contained unit with the surface it exports, filed in a modules folder.", "term": "Definition", "wide": true }, { "description": "modules/auth.module.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-module-tag", "title": "Module Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that groups names under one prefix so they cannot collide with others, filed in a namespaces folder.", "term": "Definition", "wide": true }, { "description": "namespaces/geometry.namespace.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-namespace-tag", "title": "Namespace Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that replaces a default setting for a stated scope, filed in an overrides folder.", "term": "Definition", "wide": true }, { "description": "overrides/region.override.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-override-tag", "title": "Override Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a distributable unit and what it contains, filed in a packages folder.", "term": "Definition", "wide": true }, { "description": "packages/ui-kit.package.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-package-tag", "title": "Package Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares the parameters an operation accepts with their bounds, filed in a parameters folder.", "term": "Definition", "wide": true }, { "description": "parameters/pagination.parameter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parameter-tag", "title": "Parameter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that saves state so it survives the process, filed in a persistence folder.", "term": "Definition", "wide": true }, { "description": "persistence/draft.persistence.ts", "term": "Example" }, { "description": "[Store Tag](/records/lexicon/store-tag): Persistence saves state so it survives the process, while a store holds state and controls how it is read and changed.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-persistence-tag", "title": "Persistence Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that is discovered and loaded by a host to add behavior without editing the host, filed in a plugins folder.", "term": "Definition", "wide": true }, { "description": "plugins/spell-check.plugin.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Plugins](/records/lexicon/plugins)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plugin-tag", "title": "Plugin Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies a platform feature where the running platform lacks it, filed in a polyfills folder.", "term": "Definition", "wide": true }, { "description": "polyfills/structured-clone.polyfill.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-polyfill-tag", "title": "Polyfill Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides how pooled resources are sized, lent and returned, filed in a pooling folder.", "term": "Definition", "wide": true }, { "description": "pooling/database.pooling.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pooling-tag", "title": "Pooling Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares an interface the core needs from the outside, with no implementation, filed in a ports folder.", "term": "Definition", "wide": true }, { "description": "ports/mailer.port.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Ports](/records/lexicon/ports)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-port-tag", "title": "Port Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides which of several conflicting sources of a setting wins, filed in a precedence folder.", "term": "Definition", "wide": true }, { "description": "precedence/setting-source.precedence.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-precedence-tag", "title": "Precedence Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that answers yes or no about a value, filed in a predicates folder.", "term": "Definition", "wide": true }, { "description": "predicates/weekend.predicate.ts", "term": "Example" }, { "description": "[Validator Tag](/records/lexicon/validator-tag): A predicate answers yes or no, while a validator also reports why its input is not valid.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-predicate-tag", "title": "Predicate Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a participant's own choices and how they persist, filed in a preferences folder.", "term": "Definition", "wide": true }, { "description": "preferences/notification.preference.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-preference-tag", "title": "Preference Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that loads what is likely to be needed before it is asked for, filed in a prefetching folder.", "term": "Definition", "wide": true }, { "description": "prefetching/next-page.prefetching.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prefetching-tag", "title": "Prefetching Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a smallest building block higher parts are composed from, filed in a primitives folder.", "term": "Definition", "wide": true }, { "description": "primitives/point.primitive.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-primitive-tag", "title": "Primitive Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that bundles a named set of settings chosen together, filed in a profiles folder.", "term": "Definition", "wide": true }, { "description": "profiles/staging.profile.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-profile-tag", "title": "Profile Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies an instance or a value on request, filed in a providers folder.", "term": "Definition", "wide": true }, { "description": "providers/clock.provider.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-provider-tag", "title": "Provider Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that enters members into a registry, filed in a registrars folder.", "term": "Definition", "wide": true }, { "description": "registrars/command.registrar.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-registrar-tag", "title": "Registrar Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a named set of known members and answers lookups against it, filed in a registries folder.", "term": "Definition", "wide": true }, { "description": "registries/codec.registry.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Registry](/records/lexicon/registry)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-registry-tag", "title": "Registry Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that fetches settings from a service while the program runs, filed in a remote-config folder.", "term": "Definition", "wide": true }, { "description": "remote-config/pricing.remote-config.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remote-config-tag", "title": "Remote-Config Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that gives domain code a collection-like interface over stored records, filed in a repositories folder.", "term": "Definition", "wide": true }, { "description": "repositories/customer.repository.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repository-tag", "title": "Repository Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that turns a reference into the thing it refers to, filed in a resolvers folder.", "term": "Definition", "wide": true }, { "description": "resolvers/avatar-url.resolver.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resolver-tag", "title": "Resolver Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that defines the shapes data must take, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "schemas/order.schemas.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Schema](/records/lexicon/schema)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schemas-tag", "title": "Schemas Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one configurable option with its type and default, filed in a settings folder.", "term": "Definition", "wide": true }, { "description": "settings/theme.setting.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-setting-tag", "title": "Setting Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that wraps a storage medium behind reads and writes of bytes or records, filed in a storage folder.", "term": "Definition", "wide": true }, { "description": "storage/blob.storage.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-storage-tag", "title": "Storage Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines an ordered, unbounded sequence of records processed as they arrive, filed in a streams folder.", "term": "Definition", "wide": true }, { "description": "streams/clickstream.stream.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stream-tag", "title": "Stream Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that switches between two behaviors from a control a participant sets, filed in a toggles folder.", "term": "Definition", "wide": true }, { "description": "toggles/dark-mode.toggle.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-toggle-tag", "title": "Toggle Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a named stream of messages and its schema, filed in a topics folder.", "term": "Definition", "wide": true }, { "description": "topics/order-created.topic.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-topic-tag", "title": "Topic Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares a named set of behaviors a type can implement, filed in a traits folder.", "term": "Definition", "wide": true }, { "description": "traits/ordering.trait.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trait-tag", "title": "Trait Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that declares the types other code uses, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "types/invoice.types.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-types-tag", "title": "Types Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a value that is exactly one of several declared shapes, filed in a unions folder.", "term": "Definition", "wide": true }, { "description": "unions/shape.union.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-union-tag", "title": "Union Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that assigns, compares or migrates between versions, filed in a versioning folder.", "term": "Definition", "wide": true }, { "description": "versioning/document.versioning.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-versioning-tag", "title": "Versioning Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Infrastructure Concerns](/records/lexicon-category/infrastructure-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that encloses another object to change how it is called while keeping what it does, filed in a wrappers folder.", "term": "Definition", "wide": true }, { "description": "wrappers/http-client.wrapper.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-wrapper-tag", "title": "Wrapper Tag" } ], "title": "Infrastructure Concerns" }, { "icon": "bi-book", "id": "lexicon-category-metadata-self-description-declarative-systems", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for logging which implementation was bound to each extension point and why.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-binding-decision-log", "title": "Binding Decision Log" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to generate client code automatically from an API's self-description.", "term": "Definition", "wide": true }, { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" }, { "description": "[HATEOAS-style Navigation](/records/lexicon/hateoas-style-navigation): Client generation builds client code from an API's self-description ahead of time, while hypermedia navigation follows the links each response returns.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-client-generation", "title": "Client Generation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a declared capability set drifts out of sync with the actual behavior.", "term": "Definition", "wide": true }, { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with capability-declaration", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declaration-drift", "title": "Declaration Drift" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having each component state in metadata what it provides and what it requires.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior), [Predictability](/records/architecture/predictability), [Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Describing API](/records/architecture/self-describing-api), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Metaprogramming](/records/architecture/metaprogramming), [Reflection](/records/architecture/reflection), [Introspection](/records/architecture/introspection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-capability", "title": "Declare Capability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which interpreting declarative configuration at runtime adds hidden dynamic complexity.", "term": "Definition", "wide": true }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with declarative-configuration", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-complexity", "title": "Dynamic Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process data generically by reading its self-describing structure.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-processing", "title": "Dynamic Processing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Requiring explicit configuration for everything instead of relying on sensible conventions.", "term": "Definition", "wide": true }, { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-excessive-configuration", "title": "Excessive Configuration" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that declarative configuration carry an explicit, defined meaning.", "term": "Definition", "wide": true }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-semantics", "title": "Explicit Semantics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which relying on conventions reduces the explicitness of how a system is configured.", "term": "Definition", "wide": true }, { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with convention-over-configuration", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicitness", "title": "Explicitness" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Hardcoding behavior in code instead of driving it from declarative metadata.", "term": "Definition", "wide": true }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design), [Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-behavior", "title": "Hardcoded Behavior" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Registering components with hardcoded wiring instead of declaring them in a manifest.", "term": "Definition", "wide": true }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-registration", "title": "Hardcoded Registration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for clients to navigate an API by following links it returns in its responses.", "term": "Definition", "wide": true }, { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hateoas-style-navigation", "title": "HATEOAS-style Navigation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Behavior that is opaque at runtime because the system does not describe its own structure.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-runtime-behavior", "title": "Hidden Runtime Behavior" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Leaving what a component can do implicit and undiscoverable instead of declaring it.", "term": "Definition", "wide": true }, { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Capability Declaration](/records/architecture/capability-declaration), [Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implicit-capability", "title": "Implicit Capability" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A declarative document listing a component's capabilities and metadata.", "term": "Definition", "wide": true }, { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manifest", "title": "Manifest" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a manifest drifts out of sync with the components it declares.", "term": "Definition", "wide": true }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with manifest-based-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manifest-drift", "title": "Manifest Drift" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the structure a manifest must follow.", "term": "Definition", "wide": true }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manifest-schema", "title": "Manifest Schema" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which self-describing metadata drifts out of sync with the actual system.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with self-describing-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-drift", "title": "Metadata Drift" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the metadata fields that drive a system's behavior.", "term": "Definition", "wide": true }, { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-schema", "title": "Metadata Schema" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "An API that does not describe itself, so clients must rely on external, out-of-band documentation.", "term": "Definition", "wide": true }, { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-api", "title": "Opaque API" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Using opaque binary or untyped data that carries no description of its own structure.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-binary-untyped-structures", "title": "Opaque Binary/Untyped Structures" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which embedding self-description in responses enlarges their payloads.", "term": "Definition", "wide": true }, { "description": "[Self-Describing API](/records/architecture/self-describing-api)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with self-describing-api", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-payload-verbosity", "title": "Payload Verbosity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to discover and load plugins declared in manifests at runtime.", "term": "Definition", "wide": true }, { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plugin-loading", "title": "Plugin Loading" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to avoid repetitive boilerplate by relying on conventions.", "term": "Definition", "wide": true }, { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-boilerplate", "title": "Reduced Boilerplate" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change a system's behavior by editing configuration rather than code.", "term": "Definition", "wide": true }, { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declarative Configuration](/records/architecture/declarative-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-configuration-without-code-change", "title": "Runtime Configuration without Code Change" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having a system report its loaded components and their bindings at startup.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-topology-report", "title": "Runtime Topology Report" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component exposes its own capabilities and structure for inspection.", "term": "Definition", "wide": true }, { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Capability Declaration](/records/architecture/capability-declaration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-self-description", "title": "Self-Description" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which embedding structural descriptions in data increases its size.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with self-describing-structures", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-size-overhead", "title": "Size Overhead" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the conventions a system relies on stay stable and well-known.", "term": "Definition", "wide": true }, { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Convention over Configuration](/records/architecture/convention-over-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stable-conventions", "title": "Stable Conventions" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metadata / Self-Description / Declarative Systems](/records/lexicon-category/metadata-self-description-declarative-systems)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which metadata that drives behavior is read without being validated against a schema.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metadata-Driven Design](/records/architecture/metadata-driven-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unvalidated-metadata", "title": "Unvalidated Metadata" } ], "title": "Metadata / Self-Description / Declarative Systems" }, { "icon": "bi-book", "id": "lexicon-category-metaprogramming-language-oriented-architecture", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which rules are written in an informal mini-language that has no grammar and no validator.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language), [Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-mini-language", "title": "Ad-Hoc Mini-Language" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that code be represented as a structured syntax tree or data rather than as raw text.", "term": "Definition", "wide": true }, { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ast-or-data-representation", "title": "AST or Data Representation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to remove repetitive boilerplate by generating it from a single declaration.", "term": "Definition", "wide": true }, { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-boilerplate-elimination", "title": "Boilerplate Elimination" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which moving work into the build to run at compile time makes the build harder to set up and reason about.", "term": "Definition", "wide": true }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with compile-time-evaluation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-build-complexity", "title": "Build Complexity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a domain language be backed by a generator or interpreter that executes it.", "term": "Definition", "wide": true }, { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-code-generation-or-interpreters", "title": "Code Generation or Interpreters" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a program's code be representable in the same data structures the language manipulates.", "term": "Definition", "wide": true }, { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-code-as-data-representation", "title": "Code-as-Data Representation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the inputs a computation needs be known at compile time so it can run then.", "term": "Definition", "wide": true }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compile-time-inputs", "title": "Compile-Time Inputs" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a check or generation that could run at compile time is repeated at runtime.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-static-check", "title": "Deferred Static Check" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to inspect a running system's own structure and state to diagnose it.", "term": "Definition", "wide": true }, { "description": "[Introspection](/records/architecture/introspection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Introspection](/records/architecture/introspection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-diagnostics", "title": "Diagnostics" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to express domain rules directly in terms a domain expert recognizes.", "term": "Definition", "wide": true }, { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-expressiveness", "title": "Domain Expressiveness" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Expressing a problem domain as a first-class language of its own concepts and rules.", "term": "Definition", "wide": true }, { "description": "[Domain Modeling](/records/algorithms/domain-modeling)", "term": "Contract" }, { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-modeling", "title": "Domain Modeling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to generate specialized code at runtime to optimize or adapt to observed conditions.", "term": "Definition", "wide": true }, { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-optimization-adaptation", "title": "Dynamic Optimization/Adaptation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to catch errors at compile time rather than letting them surface at runtime.", "term": "Definition", "wide": true }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-early-error-detection", "title": "Early Error Detection" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Writing code out by hand explicitly rather than generating it, favoring directness and debuggability over reuse.", "term": "Definition", "wide": true }, { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with metaprogramming", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-handwritten-code", "title": "Explicit Handwritten Code" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a domain language have a defined grammar and semantics rather than an ad-hoc syntax.", "term": "Definition", "wide": true }, { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formal-grammar-semantics", "title": "Formal Grammar/Semantics" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A precise, machine-processable model of a system from which implementations are generated.", "term": "Definition", "wide": true }, { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Formal Verification](/records/architecture/formal-verification), [Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formal-model", "title": "Formal Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Expressing domain logic through verbose general-purpose code and its boilerplate instead of a concise domain notation.", "term": "Definition", "wide": true }, { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-general-purpose-boilerplate", "title": "General-Purpose Boilerplate" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Implementation code produced automatically from a model rather than written by hand.", "term": "Definition", "wide": true }, { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-generated-implementations", "title": "Generated Implementations" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Hand-editing generated code so it drifts from the model it came from, breaking regeneration.", "term": "Definition", "wide": true }, { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-handwritten-divergence", "title": "Handwritten Divergence" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to express solutions in high-level domain terms rather than low-level general-purpose code.", "term": "Definition", "wide": true }, { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-high-level-domain-expression", "title": "High-Level Domain Expression" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that lets code transform other code at compile time by operating on its data representation.", "term": "Definition", "wide": true }, { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-macro-systems", "title": "Macro Systems" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Expressing every domain in a single general-purpose language, rather than in domain-specific notations.", "term": "Definition", "wide": true }, { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with language-oriented-programming", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-one-size-general-purpose-code", "title": "One-Size General-Purpose Code" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Syntax trees a program cannot inspect or manipulate as data, so code cannot be transformed programmatically.", "term": "Definition", "wide": true }, { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-syntax-trees", "title": "Opaque Syntax Trees" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which inspecting and dispatching on types at runtime costs performance and bypasses static safety.", "term": "Definition", "wide": true }, { "description": "[Reflection](/records/architecture/reflection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with reflection", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-performance-safety", "title": "Performance/Safety" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to analyze and rewrite a program by manipulating its structured representation.", "term": "Definition", "wide": true }, { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-program-transformation", "title": "Program Transformation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a language expose reflection, syntax trees, or code generation for programs to manipulate themselves.", "term": "Definition", "wide": true }, { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Metaprogramming](/records/architecture/metaprogramming)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reflection-ast-code-generation", "title": "Reflection/AST/Code Generation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which reflection is used to reach members that a type's contract or visibility hides.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reflection](/records/architecture/reflection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reflective-contract-bypass", "title": "Reflective Contract Bypass" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Evaluating code or expressions dynamically at runtime, trading compile-time checking for runtime flexibility.", "term": "Definition", "wide": true }, { "description": "[Compile-Time Evaluation](/records/architecture/compile-time-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with compile-time-evaluation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-dynamic-evaluation", "title": "Runtime Dynamic Evaluation" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Type information retained at runtime so a program can inspect the shape of its own values.", "term": "Definition", "wide": true }, { "description": "[Reflection](/records/architecture/reflection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Reflection](/records/architecture/reflection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-type-metadata", "title": "Runtime Type Metadata" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that runtime code generation be confined to a safe, sandboxed boundary away from untrusted input.", "term": "Definition", "wide": true }, { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-generation-boundary", "title": "Safe Generation Boundary" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which treating code as manipulable data can obscure what runs and make it harder to debug.", "term": "Definition", "wide": true }, { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with code-as-data", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safety-debuggability", "title": "Safety/Debuggability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which generating and running code at runtime widens the attack surface and complicates debugging.", "term": "Definition", "wide": true }, { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with runtime-code-generation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-security-debugging", "title": "Security/Debugging" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system carries enough metadata to describe its own structure and capabilities at runtime.", "term": "Definition", "wide": true }, { "description": "[Introspection](/records/architecture/introspection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Introspection](/records/architecture/introspection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-self-describing-systems", "title": "Self-Describing Systems" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "Building code by concatenating strings, so the result is unchecked, injection-prone, and hard to analyze.", "term": "Definition", "wide": true }, { "description": "[Code as Data](/records/architecture/code-as-data)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Code as Data](/records/architecture/code-as-data)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-string-based-code-generation", "title": "String-Based Code Generation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for generating code by building and printing a syntax tree instead of concatenating strings.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Code as Data](/records/architecture/code-as-data), [Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-syntax-tree-generation", "title": "Syntax Tree Generation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which building custom languages adds compilers, parsers, and editors to a project's toolchain.", "term": "Definition", "wide": true }, { "description": "[Language-Oriented Programming](/records/architecture/language-oriented-programming)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with language-oriented-programming", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-toolchain-complexity", "title": "Toolchain Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which owning a custom language burdens a team with building and maintaining its tooling.", "term": "Definition", "wide": true }, { "description": "[Domain-Specific Language (DSL)](/records/architecture/domain-specific-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with domain-specific-language", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tooling-maintenance", "title": "Tooling/Maintenance" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Metaprogramming / Language-Oriented Architecture](/records/lexicon-category/metaprogramming-language-oriented-architecture)", "Layer: [Declarative Core](/records/layer/declarative-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit rules define how a model maps to generated implementation code.", "term": "Definition", "wide": true }, { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model-Driven Architecture](/records/architecture/model-driven-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transformation-rules", "title": "Transformation Rules" } ], "title": "Metaprogramming / Language-Oriented Architecture" }, { "icon": "bi-book", "id": "lexicon-category-model-architecture", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having a model decline or state its uncertainty when the evidence does not support an answer.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-abstain-or-disclose-uncertainty", "title": "Abstain or Disclose Uncertainty" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Promoting exploratory notebook code straight to production without engineering it into a reliable pipeline.", "term": "Definition", "wide": true }, { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-notebook-to-production", "title": "Ad-Hoc Notebook-to-Production" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The declared rules and gates a model must pass before it may be deployed.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-approval-policy", "title": "Approval Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to inspect and trace a model's decisions for auditing and debugging.", "term": "Definition", "wide": true }, { "description": "[Explainability](/records/architecture/explainability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explainability](/records/architecture/explainability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-audit-and-debugging", "title": "Audit and Debugging" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to run agents that use external tools within defined, safe limits.", "term": "Definition", "wide": true }, { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" }, { "description": "[Governed Autonomy](/records/lexicon/governed-autonomy): Bounded tool use limits which tools an agent may call, while governed autonomy limits which decisions it may take without approval.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-tool-using-agents", "title": "Bounded Tool-Using Agents" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of usefulness a model offers, which strict safety limits can constrain.", "term": "Definition", "wide": true }, { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with model-safety", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capability-utility", "title": "Capability/Utility" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for holding model names, parameters and limits in one configuration read by every call site.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralized-model-configuration", "title": "Centralized Model Configuration" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking generated claims against their cited sources before they are returned.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-claim-validation", "title": "Claim Validation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to generate output informed by retrieved, task-specific context.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contextual-generation", "title": "Contextual Generation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to release models through a governed, approved process.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-model-deployment", "title": "Controlled Model Deployment" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of ongoing effort required to build and maintain a curated knowledge graph.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with knowledge-graphs", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-curation-cost", "title": "Curation Cost" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The stages that ingest, clean, and transform data into a form suitable for training or inference.", "term": "Definition", "wide": true }, { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-pipeline", "title": "Data Pipeline" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The lines separating data preparation, model training, and serving so each concern stays isolated.", "term": "Definition", "wide": true }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-model-boundaries", "title": "Data/Model Boundaries" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A curated collection of examples used to train or evaluate a model.", "term": "Definition", "wide": true }, { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dataset", "title": "Dataset" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect when a model's accuracy declines as data shifts.", "term": "Definition", "wide": true }, { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-degradation-detection", "title": "Degradation Detection" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Deploying a model and never monitoring it, so degradation as the data drifts goes unnoticed.", "term": "Definition", "wide": true }, { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" }, { "description": "[Model Drift](/records/lexicon/model-drift): Deploy-and-forget is never watching a model after release, while model drift is the loss of fidelity that goes unseen as a result.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deploy-and-forget-models", "title": "Deploy-and-Forget Models" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The body of documents a retrieval system searches to ground a model's generation.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-document-store", "title": "Document Store" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Numeric vector representations of data that place semantically similar items near each other.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" }, { "description": "[Vector Index](/records/lexicon/vector-index): Embeddings are the vectors themselves, while a vector index organizes them for nearest-neighbor lookup.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-embeddings", "title": "Embeddings" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The distinct things, such as people, places or concepts, that a knowledge graph represents as nodes.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" }, { "description": "[Relations](/records/lexicon/relations): Entities are a knowledge graph's nodes, while relations are its edges.", "term": "Distinct from" }, { "description": "[Schema/Ontology](/records/lexicon/schema-ontology): Entities are the instances in the graph, while the schema defines the entity types they belong to.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-entities", "title": "Entities" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for scoring model output against a fixed set of cases on every change to the model, prompt or data.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl), [Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Model Governance](/records/architecture/model-governance), [Model Evaluation](/records/architecture/model-evaluation), [Vector Search](/records/architecture/vector-search), [Model Safety](/records/architecture/model-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evaluation-suite", "title": "Evaluation Suite" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for attaching to each generated claim the retrieved source that supports it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ungrounded Content](/records/architecture/ungrounded-content), [Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation), [Explainability](/records/architecture/explainability), [Compliance](/records/architecture/compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evidence-citation", "title": "Evidence Citation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Relying solely on exact keyword matching for retrieval, missing semantically related results.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exact-keyword-search-only", "title": "Exact Keyword Search Only" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which model experiments can be run and iterated, which governance can slow.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with model-governance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-experiment-velocity", "title": "Experiment Velocity" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which new modeling ideas can be tried and evaluated.", "term": "Definition", "wide": true }, { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with machine-learning-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-experimentation-speed", "title": "Experimentation Speed" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which retrieval stays explainable and complete, traded against pure similarity ranking.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with vector-search", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explainability-recall", "title": "Explainability/Recall" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Representing knowledge as unlinked flat documents, losing the relationships a graph would capture.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flat-document-only-knowledge", "title": "Flat Document-Only Knowledge" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording each approval, deployment and retirement of a model with who decided it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-governance-log", "title": "Governance Log" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let an agent act autonomously within enforced governance limits.", "term": "Definition", "wide": true }, { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-governed-autonomy", "title": "Governed Autonomy" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A scheme for anchoring a model's output in retrieved, authoritative sources rather than its parameters alone.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-grounding-strategy", "title": "Grounding Strategy" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Constraints and filters that bound what a model is permitted to output or do at runtime.", "term": "Definition", "wide": true }, { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency), [Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Model Safety](/records/architecture/model-safety), [Agentic Architecture](/records/architecture/agentic-architecture), [Auto-Remediation](/records/architecture/auto-remediation), [Canary Deployment](/records/architecture/canary-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guardrails", "title": "Guardrails" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for logging with each model output the model version, prompt version and inputs that produced it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inference-context-record", "title": "Inference Context Record" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The agreed schema of the inputs a model accepts and the outputs it returns.", "term": "Definition", "wide": true }, { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-input-output-contract", "title": "Input/Output Contract" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system's knowledge reflects current rather than stale information.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-knowledge-freshness", "title": "Knowledge Freshness" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of latency and expense incurred to serve model predictions.", "term": "Definition", "wide": true }, { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with model-inference", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-cost", "title": "Latency/Cost" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which evaluation metrics capture every dimension of a model's quality.", "term": "Definition", "wide": true }, { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with model-evaluation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metric-completeness", "title": "Metric Completeness" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The trained model file, with its learned weights, that is loaded to serve predictions.", "term": "Definition", "wide": true }, { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-artifact", "title": "Model Artifact" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of intricacy in a model, which raises accuracy but lowers explainability.", "term": "Definition", "wide": true }, { "description": "[Explainability](/records/architecture/explainability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with explainability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-complexity", "title": "Model Complexity" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A catalog that tracks model versions, their metadata, and their deployment status.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity), [Model Governance](/records/architecture/model-governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-registry", "title": "Model Registry" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to compare models and catch quality regressions before deployment.", "term": "Definition", "wide": true }, { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-selection-regression-detection", "title": "Model Selection/Regression Detection" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability of a software system to incorporate models as integral parts of its behavior.", "term": "Definition", "wide": true }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-integrated-systems", "title": "Model-Integrated Systems" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of ongoing expense of continuously monitoring a deployed model.", "term": "Definition", "wide": true }, { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with model-drift-monitoring", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-monitoring-cost", "title": "Monitoring Cost" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Producing model decisions with no explanation, so their reasoning cannot be inspected or trusted.", "term": "Definition", "wide": true }, { "description": "[Explainability](/records/architecture/explainability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explainability](/records/architecture/explainability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-black-box-decisions", "title": "Opaque Black-Box Decisions" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Using models with no governance or oversight, leaving their behavior and risks unmanaged.", "term": "Definition", "wide": true }, { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Artificial Intelligence Architecture](/records/architecture/artificial-intelligence-architecture), [Model Inference](/records/architecture/model-inference)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-ungoverned-model-use", "title": "Opaque Ungoverned Model Use" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping prompts in one versioned registry instead of as literals across the code.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl), [Prompt Engineering](/records/architecture/prompt-engineering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prompt-registry", "title": "Prompt Registry" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for giving each prompt, dataset and index a version that inference logs record.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prompt Sprawl](/records/architecture/prompt-sprawl), [Model Version Ambiguity](/records/architecture/model-version-ambiguity), [Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prompt-versioning", "title": "Prompt Versioning" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The reasons and supporting evidence recorded for a model's decision.", "term": "Definition", "wide": true }, { "description": "[Explainability](/records/architecture/explainability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explainability](/records/architecture/explainability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rationale-evidence", "title": "Rationale/Evidence" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The typed connections between entities that a knowledge graph represents as edges.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" }, { "description": "[Schema/Ontology](/records/lexicon/schema-ontology): Relations are the edges present in the graph, while the schema defines the relationship types allowed.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-relations", "title": "Relations" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to retrieve and reason over the relationships between entities, not just isolated facts.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-relationship-aware-retrieval-reasoning", "title": "Relationship-Aware Retrieval/Reasoning" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to manage a model's data, training, deployment and monitoring reliably and repeatably.", "term": "Definition", "wide": true }, { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-model-lifecycle", "title": "Reliable Model Lifecycle" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Signals that automatically initiate model retraining when measured drift crosses a threshold.", "term": "Definition", "wide": true }, { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Drift Monitoring](/records/architecture/model-drift-monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retraining-triggers", "title": "Retraining Triggers" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which retrieval must trade result quality against speed.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with retrieval-augmented-generation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retrieval-quality-latency", "title": "Retrieval Quality/Latency" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A component that finds and returns the most relevant documents for a query.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retriever", "title": "Retriever" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deploy models with safeguards that bound their behavior.", "term": "Definition", "wide": true }, { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-model-deployment", "title": "Safe Model Deployment" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the entity types and relationship types a knowledge graph may contain.", "term": "Definition", "wide": true }, { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Knowledge Graphs](/records/architecture/knowledge-graphs)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schema-ontology", "title": "Schema/Ontology" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to find results by meaning and similarity rather than exact keyword match.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-semantic-search", "title": "Semantic Search" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to retrieve items nearest to a query in an embedding space.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-similarity-retrieval", "title": "Similarity Retrieval" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Prompts authored as structured, version-controlled artifacts rather than ad-hoc strings.", "term": "Definition", "wide": true }, { "description": "[Prompt Engineering](/records/architecture/prompt-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Prompt Engineering](/records/architecture/prompt-engineering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structured-versioned-prompts", "title": "Structured, Versioned Prompts" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The defined contract through which an agent invokes external tools and receives their results.", "term": "Definition", "wide": true }, { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agentic Architecture](/records/architecture/agentic-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tool-interface", "title": "Tool Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Building logic that exists only during training, with no counterpart to serve predictions at inference.", "term": "Definition", "wide": true }, { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Inference](/records/architecture/model-inference)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-training-time-only-model-logic", "title": "Training-Time-Only Model Logic" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that model training and prediction serving be distinct, separately-managed phases.", "term": "Definition", "wide": true }, { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Machine Learning Architecture](/records/architecture/machine-learning-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-training-inference-separation", "title": "Training/Inference Separation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which users are willing to rely on a system's outputs.", "term": "Definition", "wide": true }, { "description": "[Explainability](/records/architecture/explainability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explainability](/records/architecture/explainability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trust", "title": "Trust" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Deploying a model to production without passing the required review and approval gates.", "term": "Definition", "wide": true }, { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Referenced by" }, { "description": "[Model Version Ambiguity](/records/architecture/model-version-ambiguity): Unapproved deployment skips the approval gate, while version ambiguity loses track of which version and configuration is running.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Governance](/records/architecture/model-governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unapproved-model-deployment", "title": "Unapproved Model Deployment" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Generating output from a model alone without grounding it in retrieved facts, inviting hallucination.", "term": "Definition", "wide": true }, { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Retrieval-Augmented Generation (RAG)](/records/architecture/retrieval-augmented-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ungrounded-generation", "title": "Ungrounded Generation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Letting a model act autonomously with no safety guardrails on what it can do.", "term": "Definition", "wide": true }, { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Safety](/records/architecture/model-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unguarded-model-autonomy", "title": "Unguarded Model Autonomy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Deploying a model without evaluating it, so its real-world quality is unknown until it fails.", "term": "Definition", "wide": true }, { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Model Evaluation](/records/architecture/model-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-untested-model-deployment", "title": "Untested Model Deployment" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Model Architecture](/records/lexicon-category/model-architecture)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A data structure that organizes embedding vectors for fast nearest-neighbor lookup.", "term": "Definition", "wide": true }, { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vector Search](/records/architecture/vector-search)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vector-index", "title": "Vector Index" } ], "title": "Model Architecture" }, { "icon": "bi-book", "id": "lexicon-category-observability-auditability-traceability", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to attribute every consequential action to the actor responsible for it.", "term": "Definition", "wide": true }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auditability](/records/architecture/auditability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-accountability", "title": "Accountability" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A field of an audit record identifying the operation that was performed.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" }, { "description": "[Target](/records/lexicon/target): The action field names the operation, while the target field names the resource it was performed on.", "term": "Distinct from" }, { "description": "[Timestamp](/records/lexicon/timestamp): The action field names the operation, while the timestamp field marks when it happened.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-action", "title": "Action" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A field of an audit record identifying who or what performed an action.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" }, { "description": "[Action](/records/lexicon/action): The actor field names who acted, while the action field names what was done.", "term": "Distinct from" }, { "description": "[Target](/records/lexicon/target): The actor field names who acted, while the target field names what was acted on.", "term": "Distinct from" }, { "description": "[Timestamp](/records/lexicon/timestamp): The actor field names who acted, while the timestamp field marks when.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-actor", "title": "Actor" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which too many alerts desensitize responders, so the ones that matter are ignored.", "term": "Definition", "wide": true }, { "description": "[Alerting](/records/architecture/alerting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with alerting", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alert-fatigue", "title": "Alert Fatigue" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which monitoring many signals generates alerts that drown out the meaningful ones.", "term": "Definition", "wide": true }, { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with monitoring", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alert-noise", "title": "Alert Noise" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for raising an alert with an owner and a severity when a critical path fails.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure), [Log-as-Control-Flow](/records/architecture/log-as-control-flow), [Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alert-on-critical-failure", "title": "Alert on Critical Failure" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Data or requests flowing through a system with no identifiers, so their path cannot be reconstructed.", "term": "Definition", "wide": true }, { "description": "[Traceability](/records/architecture/traceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Traceability](/records/architecture/traceability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anonymous-flow", "title": "Anonymous Flow" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to see a system's overall health at a glance from a consolidated visual display.", "term": "Definition", "wide": true }, { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Referenced by" }, { "description": "[Trend Visibility](/records/lexicon/trend-visibility): At-a-glance health shows the state now, while trend visibility shows how a metric has moved over time.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-at-a-glance-system-health", "title": "At-a-Glance System Health" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A chronological record linking each event to the one that caused it.", "term": "Definition", "wide": true }, { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-audit-trail", "title": "Audit Trail" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Running a system in production with no monitoring, so problems are noticed only when users report them.", "term": "Definition", "wide": true }, { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability](/records/architecture/observability), [Monitoring](/records/architecture/monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blind-operation", "title": "Blind Operation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for limiting the distinct label values a metric carries, so its storage and queries stay bounded.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability Noise](/records/architecture/observability-noise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cardinality-reduction", "title": "Cardinality Reduction" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for carrying the id of the event or request that caused each effect, so a chain can be followed back.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Action at a Distance](/records/architecture/action-at-a-distance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-causation-tracing", "title": "Causation Tracing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reconstruct which event triggered which by following causation identifiers.", "term": "Definition", "wide": true }, { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cause-effect-reconstruction", "title": "Cause-Effect Reconstruction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that request context be carried across service boundaries so related calls can be correlated.", "term": "Definition", "wide": true }, { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-propagation", "title": "Context Propagation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which collecting more telemetry adds cost and noise that can obscure the signals that matter.", "term": "Definition", "wide": true }, { "description": "[Observability](/records/architecture/observability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with observability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-noise", "title": "Cost/Noise" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which unchecked creation of dashboards scatters attention across too many redundant views.", "term": "Definition", "wide": true }, { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dashboards", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dashboard-sprawl", "title": "Dashboard Sprawl" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording who changed which data, when, and from what value to what value.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption), [Architecture Decision Records (ADR)](/records/architecture/architecture-decision-records), [Auditability](/records/architecture/auditability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-change-audit", "title": "Data Change Audit" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stating what makes a log, metric or alert useful before it is emitted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability Noise](/records/architecture/observability-noise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-define-signal-quality", "title": "Define Signal Quality" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to follow a request's cause-and-effect chain across every component it touches.", "term": "Definition", "wide": true }, { "description": "[Traceability](/records/architecture/traceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Traceability](/records/architecture/traceability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-end-to-end-causality", "title": "End-to-End Causality" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to decide how much risk to take by spending against a defined reliability error budget.", "term": "Definition", "wide": true }, { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-budget-decisions", "title": "Error-Budget Decisions" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive fields attached to an event, such as its identifiers, timestamps, and causation links.", "term": "Definition", "wide": true }, { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-metadata", "title": "Event Metadata" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording each step an automated or manual procedure performed and its result.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-execution-log", "title": "Execution Log" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect that a system has failed or degraded by watching its monitored signals.", "term": "Definition", "wide": true }, { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-detection", "title": "Failure Detection" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which holding to strict reliability targets limits how fast new features can ship.", "term": "Definition", "wide": true }, { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with slo-sli", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-velocity", "title": "Feature Velocity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reconstruct after the fact what happened from an immutable audit record.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-forensics", "title": "Forensics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which threading correlation identifiers through headers adds handling to every call.", "term": "Definition", "wide": true }, { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with correlation-id", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-header-metadata-management", "title": "Header/Metadata Management" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reconstruct and analyze an incident from the events a system logged.", "term": "Definition", "wide": true }, { "description": "[Logging](/records/architecture/logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Logging](/records/architecture/logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incident-analysis", "title": "Incident Analysis" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to diagnose the cause of an incident from a system's observable signals.", "term": "Definition", "wide": true }, { "description": "[Observability](/records/architecture/observability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability](/records/architecture/observability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incident-diagnosis", "title": "Incident Diagnosis" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Detecting, triaging, and resolving an operational incident once an alert fires.", "term": "Definition", "wide": true }, { "description": "[Alerting](/records/architecture/alerting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incident-response", "title": "Incident Response" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to pinpoint which service caused a request's latency or failure by tracing it across hops.", "term": "Definition", "wide": true }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-failure-root-cause-analysis", "title": "Latency/Failure Root Cause Analysis" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Diagnosing problems solely by grepping raw logs, with no aggregated view of system health.", "term": "Definition", "wide": true }, { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-log-grep-only-diagnosis", "title": "Log-Grep-Only Diagnosis" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A record of discrete, timestamped events a system emits about what it did.", "term": "Definition", "wide": true }, { "description": "[Observability](/records/architecture/observability)", "term": "Referenced by" }, { "description": "[Traces](/records/lexicon/traces): Logs record discrete events, while traces record the path and timing of one request across components.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability](/records/architecture/observability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-logs", "title": "Logs" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The combined log and trace records that let a request be followed from end to end.", "term": "Definition", "wide": true }, { "description": "[Traceability](/records/architecture/traceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Traceability](/records/architecture/traceability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-logs-traces", "title": "Logs/Traces" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which carrying trace metadata through every call adds size and processing cost.", "term": "Definition", "wide": true }, { "description": "[Traceability](/records/architecture/traceability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with traceability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-propagation-overhead", "title": "Metadata Propagation Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which stamping every event with causation metadata makes the event payload verbose.", "term": "Definition", "wide": true }, { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with causation-id", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metadata-verbosity", "title": "Metadata Verbosity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which verbose logging adds noise and risks leaking personal or sensitive data.", "term": "Definition", "wide": true }, { "description": "[Logging](/records/architecture/logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with logging", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-noise-personal-data-leakage", "title": "Noise/Personal Data Leakage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Calls crossing service boundaries with no tracing, so a request's path and bottlenecks are invisible.", "term": "Definition", "wide": true }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-distributed-calls", "title": "Opaque Distributed Calls" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Changing state with no record of who changed what or when, so the change cannot be audited.", "term": "Definition", "wide": true }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auditability](/records/architecture/auditability), [Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-opaque-mutation", "title": "Opaque Mutation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which tracing every request adds overhead, forcing sampling that can miss rare cases.", "term": "Definition", "wide": true }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with distributed-tracing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-overhead-sampling", "title": "Overhead/Sampling" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system limits the collection and exposure of personal or sensitive information.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with audit-logging", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-privacy", "title": "Privacy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to trace all work belonging to one request by a shared correlation identifier.", "term": "Definition", "wide": true }, { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-request-level-traceability", "title": "Request-Level Traceability" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for naming the person or team responsible for each alert and its response steps.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability Noise](/records/architecture/observability-noise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runbook-owner", "title": "Runbook Owner" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keeping a representative share of telemetry or a summary of it instead of every event.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability Noise](/records/architecture/observability-noise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sampling-and-aggregation", "title": "Sampling and Aggregation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for choosing measured indicators of reliability and setting the targets a service must meet on them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Contract](/records/architecture/service-contract), [Monitoring](/records/architecture/monitoring), [SLO/SLI](/records/architecture/slo-sli)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-service-level-objectives", "title": "Service Level Objectives" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which retaining a full audit history grows storage and raises privacy concerns.", "term": "Definition", "wide": true }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with auditability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-storage-privacy", "title": "Storage/Privacy" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Log entries emitted as structured, machine-parsable records rather than free-form text.", "term": "Definition", "wide": true }, { "description": "[Logging](/records/architecture/logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Logging](/records/architecture/logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structured-events", "title": "Structured Events" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing log entries as typed fields, so they are queried by field instead of by text.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure), [Observability](/records/architecture/observability), [Logging](/records/architecture/logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structured-log", "title": "Structured Log" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A field of an audit record identifying the resource an action was performed on.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-target", "title": "Target" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to intervene on a problem quickly by being alerted the moment it arises.", "term": "Definition", "wide": true }, { "description": "[Alerting](/records/architecture/alerting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Alerting](/records/architecture/alerting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timely-intervention", "title": "Timely Intervention" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A field of an audit record marking when an action occurred.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" }, { "description": "[Target](/records/lexicon/target): The timestamp field marks when an action happened, while the target field names what it was performed on.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timestamp", "title": "Timestamp" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that trace identifiers be propagated across every hop of a distributed request.", "term": "Definition", "wide": true }, { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Distributed Tracing](/records/architecture/distributed-tracing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trace-context-propagation", "title": "Trace Context Propagation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording the start, end and context of an operation as a span within a request's trace.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unobservable Failure](/records/architecture/unobservable-failure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trace-span", "title": "Trace Span" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A record of the path and timing of a request as it moves through a system's components.", "term": "Definition", "wide": true }, { "description": "[Observability](/records/architecture/observability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Observability](/records/architecture/observability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-traces", "title": "Traces" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ability to see how a metric is trending over time from a visualized history.", "term": "Definition", "wide": true }, { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dashboards](/records/architecture/dashboards)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trend-visibility", "title": "Trend Visibility" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Emitting events with no shared identifier, so those belonging to one request cannot be tied together.", "term": "Definition", "wide": true }, { "description": "[Correlation ID](/records/architecture/correlation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Traceability](/records/architecture/traceability), [Correlation ID](/records/architecture/correlation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uncorrelated-events", "title": "Uncorrelated Events" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Recording events with no link to their cause, so cause-and-effect chains cannot be rebuilt.", "term": "Definition", "wide": true }, { "description": "[Causation ID](/records/architecture/causation-id)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Causality](/records/architecture/causality), [Causation ID](/records/architecture/causation-id)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unlinked-events", "title": "Unlinked Events" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Mutating state without writing an audit entry, so the change leaves no trace.", "term": "Definition", "wide": true }, { "description": "[Audit Logging](/records/architecture/audit-logging)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auditability](/records/architecture/auditability), [Audit Logging](/records/architecture/audit-logging)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-untracked-mutation", "title": "Untracked Mutation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "A technique for counting calls to a code path in production, so its use is measured before it is removed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lava Flow](/records/architecture/lava-flow)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-usage-instrumentation", "title": "Usage Instrumentation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Observability / Auditability / Traceability](/records/lexicon-category/observability-auditability-traceability)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "Stating reliability aims in vague, unmeasurable terms, so no check can tell whether they are met.", "term": "Definition", "wide": true }, { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[SLO/SLI](/records/architecture/slo-sli)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vague-reliability-goals", "title": "Vague Reliability Goals" } ], "title": "Observability / Auditability / Traceability" }, { "icon": "bi-book", "id": "lexicon-category-operations-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a condition that warrants attention and who is told, filed in an alerts folder.", "term": "Definition", "wide": true }, { "description": "alerts/error-rate.alert.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alert-tag", "title": "Alert Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that stops work in progress when its caller no longer needs the result, filed in a cancellation folder.", "term": "Definition", "wide": true }, { "description": "cancellation/download.cancellation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cancellation-tag", "title": "Cancellation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that counts occurrences of one kind of event, filed in a counters folder.", "term": "Definition", "wide": true }, { "description": "counters/signup.counter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-counter-tag", "title": "Counter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that recognizes a repeated request or record and processes it once, filed in a deduplication folder.", "term": "Definition", "wide": true }, { "description": "deduplication/webhook-delivery.deduplication.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Deduplication](/records/lexicon/deduplication)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deduplication-tag", "title": "Deduplication Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the errors a unit can raise and what each carries, filed in an errors folder.", "term": "Definition", "wide": true }, { "description": "errors/payment.error.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-tag", "title": "Error Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that contains a failure within one part so the rest keeps running, filed in an error-boundaries folder.", "term": "Definition", "wide": true }, { "description": "error-boundaries/dashboard.error-boundary.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-boundary-tag", "title": "Error-Boundary Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares the stable codes callers match failures on, filed in an error-codes folder.", "term": "Definition", "wide": true }, { "description": "error-codes/billing.error-code.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-code-tag", "title": "Error-Code Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that sends failures with their context to where they are tracked, filed in an error-reporting folder.", "term": "Definition", "wide": true }, { "description": "error-reporting/crash.error-reporting.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-reporting-tag", "title": "Error-Reporting Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a thrown condition that interrupts normal flow, filed in an exceptions folder.", "term": "Definition", "wide": true }, { "description": "exceptions/timeout.exception.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-exception-tag", "title": "Exception Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that describes how an operation failed so its caller can decide what to do, filed in a failures folder.", "term": "Definition", "wide": true }, { "description": "failures/upload.failure.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-failure-tag", "title": "Failure Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies a declared substitute when the primary path fails, filed in a fallbacks folder.", "term": "Definition", "wide": true }, { "description": "fallbacks/avatar.fallback.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Fallback](/records/lexicon/fallback)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fallback-tag", "title": "Fallback Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that describes a defect in a component that can cause failures, filed in a faults folder.", "term": "Definition", "wide": true }, { "description": "faults/disk.fault.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fault-tag", "title": "Fault Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that answers whether a component is able to do its work, filed in a health folder.", "term": "Definition", "wide": true }, { "description": "health/database.health.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-health-tag", "title": "Health Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines and records a measured quantity over time, filed in a metrics folder.", "term": "Definition", "wide": true }, { "description": "metrics/request-latency.metric.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Metrics](/records/lexicon/metrics)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-metric-tag", "title": "Metric Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that delivers a message to a participant through a declared channel, filed in a notifications folder.", "term": "Definition", "wide": true }, { "description": "notifications/password-reset.notification.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-notification-tag", "title": "Notification Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that observes a running system and records what it finds without changing it, filed in a probes folder.", "term": "Definition", "wide": true }, { "description": "probes/queue-depth.probe.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-probe-tag", "title": "Probe Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that returns a failed part to a working state, filed in a recovery folder.", "term": "Definition", "wide": true }, { "description": "recovery/connection.recovery.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Recovery](/records/lexicon/recovery)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-recovery-tag", "title": "Recovery Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that renders findings or measurements for the party that asked for them, filed in a reporters folder.", "term": "Definition", "wide": true }, { "description": "reporters/test-run.reporter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reporter-tag", "title": "Reporter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that keeps an operation working through transient failures of what it depends on, filed in a resilience folder.", "term": "Definition", "wide": true }, { "description": "resilience/inventory-api.resilience.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resilience-tag", "title": "Resilience Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a return value carrying either a success or a failure, filed in a results folder.", "term": "Definition", "wide": true }, { "description": "results/login.result.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-result-tag", "title": "Result Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Operations Concerns](/records/lexicon-category/operations-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that limits how often an operation may run, filed in a throttling folder.", "term": "Definition", "wide": true }, { "description": "throttling/login-attempt.throttling.ts", "term": "Example" }, { "description": "[Timer Tag](/records/lexicon/timer-tag): Throttling limits how often an operation may run, while a timer runs work after a delay or at a fixed rate.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-throttling-tag", "title": "Throttling Tag" } ], "title": "Operations Concerns" }, { "icon": "bi-book", "id": "lexicon-category-plugin-extensibility-ioc", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which adding extension points enlarges the public API that must be kept stable.", "term": "Definition", "wide": true }, { "description": "[Extension Points](/records/architecture/extension-points)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with extension-points", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-api-surface-growth", "title": "API Surface Growth" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A core that cannot be extended without modifying its own source, so every addition edits the core.", "term": "Definition", "wide": true }, { "description": "[Extension Points](/records/architecture/extension-points)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility), [Extension Points](/records/architecture/extension-points)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-closed-core", "title": "Closed Core" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which injecting many dependencies through constructors makes them long and unwieldy.", "term": "Definition", "wide": true }, { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dependency-injection", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-constructor-complexity", "title": "Constructor Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to release changes to production continuously through an automated pipeline.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuous-delivery", "title": "Continuous Delivery" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deploy code and separately decide when to activate it for users.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" }, { "description": "[Gradual Rollout](/records/lexicon/gradual-rollout): Decoupling deploy from release separates shipping code from switching it on, while gradual rollout switches it on for a growing share of users.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-decoupled-deploy-and-release", "title": "Decoupled Deploy and Release" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Application code driving the overall control flow itself instead of ceding it to a framework or container.", "term": "Definition", "wide": true }, { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-control-ownership", "title": "Direct Control Ownership" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Referring to a specific implementation directly instead of looking it up through a registry.", "term": "Definition", "wide": true }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-reference", "title": "Direct Reference" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to find a registered component by key at runtime.", "term": "Definition", "wide": true }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-lookup", "title": "Dynamic Lookup" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to resolve a service's current location or instance at runtime.", "term": "Definition", "wide": true }, { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-resolution", "title": "Dynamic Resolution" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component's dependencies are visible in its signature rather than acquired through hidden lookups.", "term": "Definition", "wide": true }, { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Referenced by" }, { "description": "[Explicit Dependency](/records/lexicon/explicit-dependency): Explicit dependencies is the degree to which a component's needs are visible, while explicit dependency is the technique that makes them visible.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with service-locator-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-dependencies", "title": "Explicit Dependencies" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that feature-flag values live in external configuration, not hardcoded in the code.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-externalized-flag-state", "title": "Externalized Flag State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which stale, unremoved feature flags accumulate and clutter the code over time.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with feature-toggle", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flag-debt", "title": "Flag Debt" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let a framework drive the overall control flow and call into application code.", "term": "Definition", "wide": true }, { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Inversion of Control (IoC)](/records/architecture/inversion-of-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-framework-control-flow", "title": "Framework Control Flow" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a global registry behaves as shared global state that any code can reach.", "term": "Definition", "wide": true }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with registry-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-state", "title": "Global State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to enable a feature for a growing subset of users over time.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-gradual-rollout", "title": "Gradual Rollout" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Controlling a feature with a hardcoded constant in the code instead of an externally-managed flag.", "term": "Definition", "wide": true }, { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Feature Toggle](/records/architecture/feature-toggle)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-branch-constant", "title": "Hardcoded Branch Constant" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Wiring extensions directly into the core so adding one requires editing and rebuilding the core.", "term": "Definition", "wide": true }, { "description": "[Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Plugin Architecture](/records/architecture/plugin-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-extensions", "title": "Hardcoded Extensions" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Creating dependencies with hardcoded constructors inside a class instead of injecting them.", "term": "Definition", "wide": true }, { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" }, { "description": "[Ambient Context](/records/architecture/ambient-context): Hardcoded instantiation constructs a dependency inside the class, while ambient context reads request or user state from an implicit global.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-instantiation", "title": "Hardcoded Instantiation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Hardcoding a service's address or instance instead of resolving it through a registry.", "term": "Definition", "wide": true }, { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-lookup", "title": "Hardcoded Lookup" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each component register under a unique key by which it can be retrieved.", "term": "Definition", "wide": true }, { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-keyed-registration", "title": "Keyed Registration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to defer resolving which implementation to use until the moment it is needed.", "term": "Definition", "wide": true }, { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-late-resolution", "title": "Late Resolution" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to substitute test doubles for real dependencies by injecting them.", "term": "Definition", "wide": true }, { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dependency Injection](/records/architecture/dependency-injection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mocking", "title": "Mocking" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement of a defined protocol by which services register and deregister themselves.", "term": "Definition", "wide": true }, { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-registration-protocol", "title": "Registration Protocol" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A central store that maps keys to registered components for later lookup.", "term": "Definition", "wide": true }, { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-registry", "title": "Registry" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the whole system's operation depends on the service registry staying available.", "term": "Definition", "wide": true }, { "description": "[Service Registry](/records/architecture/service-registry)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with service-registry", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-registry-availability", "title": "Registry Availability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to look up a needed service by name at runtime.", "term": "Definition", "wide": true }, { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Locator Pattern](/records/architecture/service-locator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-lookup", "title": "Runtime Lookup" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for outside developers to extend the system through published extension points.", "term": "Definition", "wide": true }, { "description": "[Extension Points](/records/architecture/extension-points)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Extension Points](/records/architecture/extension-points)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-third-party-extension", "title": "Third-Party Extension" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Plugin / Extensibility / IoC](/records/lexicon-category/plugin-extensibility-ioc)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a global registry is changed from anywhere, with no owner, lifecycle or validation of its entries.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry Pattern](/records/architecture/registry-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ungoverned-global-registry", "title": "Ungoverned Global Registry" } ], "title": "Plugin / Extensibility / IoC" }, { "icon": "bi-book", "id": "lexicon-category-portability-infrastructure-deployment", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A boundary abstraction separating core logic from external protocols via port interfaces and pluggable adapters.", "term": "Definition", "wide": true }, { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-adapter-port-abstraction", "title": "Adapter/Port Abstraction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the relevant external standard a system must meet be identified and adhered to.", "term": "Definition", "wide": true }, { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-applicable-standard", "title": "Applicable Standard" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to create and configure infrastructure automatically from declarative definitions.", "term": "Definition", "wide": true }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-provisioning", "title": "Automated Provisioning" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to certify a system and interoperate with others by conforming to a shared standard.", "term": "Definition", "wide": true }, { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-certification-compatibility", "title": "Certification/Compatibility" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A schema defining the structure, types, and defaults of a system's externalized configuration.", "term": "Definition", "wide": true }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-config-schema", "title": "Config Schema" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which externalizing configuration across many sources scatters it and makes it hard to track.", "term": "Definition", "wide": true }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with configuration-externalization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-config-sprawl", "title": "Config Sprawl" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deploy the same software unchanged across different operating systems and platforms.", "term": "Definition", "wide": true }, { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-platform-deployment", "title": "Cross-Platform Deployment" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which replacing whole instances rather than patching them in place lengthens deployment time.", "term": "Definition", "wide": true }, { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with immutable-infrastructure", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deploy-time", "title": "Deploy Time" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to redeploy infrastructure identically every time from one fixed definition.", "term": "Definition", "wide": true }, { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Referenced by" }, { "description": "[Instance Replacement over Mutation](/records/lexicon/instance-replacement-over-mutation): Deterministic redeploys are the identical result from one fixed definition, while replacement over mutation is the method of discarding instances instead of changing them.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deterministic-redeploys", "title": "Deterministic Redeploys" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deploy one build into different environments by supplying environment-specific configuration.", "term": "Definition", "wide": true }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-environment-specific-deployment", "title": "Environment-Specific Deployment" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that configuration live outside the container image so one image runs in any environment.", "term": "Definition", "wide": true }, { "description": "[Containerization](/records/architecture/containerization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Containerization](/records/architecture/containerization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-externalized-config", "title": "Externalized Config" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Deploying software that depends on specifics of its host machine, so it cannot be moved or reproduced elsewhere.", "term": "Definition", "wide": true }, { "description": "[Containerization](/records/architecture/containerization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Containerization](/records/architecture/containerization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-host-coupled-deployment", "title": "Host-Coupled Deployment" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which packaging everything into a container image grows the image and its maintenance burden.", "term": "Definition", "wide": true }, { "description": "[Containerization](/records/architecture/containerization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with containerization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-image-complexity", "title": "Image Complexity" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A declarative file specifying how a container image is built from a base and its dependencies.", "term": "Definition", "wide": true }, { "description": "[Containerization](/records/architecture/containerization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Containerization](/records/architecture/containerization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-image-definition", "title": "Image Definition" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Modifying running servers in place over time, so their state drifts and can no longer be reproduced.", "term": "Definition", "wide": true }, { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-in-place-server-mutation", "title": "In-Place Server Mutation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which conforming to an external standard limits the freedom to innovate beyond it.", "term": "Definition", "wide": true }, { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with standards-compliance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-innovation-flexibility", "title": "Innovation/Flexibility" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to update infrastructure by replacing instances wholesale rather than mutating them in place.", "term": "Definition", "wide": true }, { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Immutable Infrastructure](/records/architecture/immutable-infrastructure)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-instance-replacement-over-mutation", "title": "Instance Replacement over Mutation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Changing infrastructure by hand instead of through code, so its state is undocumented and unreproducible.", "term": "Definition", "wide": true }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manual-infrastructure-changes", "title": "Manual Infrastructure Changes" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which staying platform-independent forgoes optimizations native to a specific platform.", "term": "Definition", "wide": true }, { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with platform-independence", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-native-optimization", "title": "Native Optimization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Depending on one operating system or vendor's proprietary features, so switching away becomes costly or impossible.", "term": "Definition", "wide": true }, { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-os-vendor-lock-in", "title": "OS/Vendor Lock-In" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that platform-specific details sit behind an abstraction the rest of the system depends on.", "term": "Definition", "wide": true }, { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Platform Independence](/records/architecture/platform-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-platform-abstraction", "title": "Platform Abstraction" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to move a system to a different platform with little or no rework.", "term": "Definition", "wide": true }, { "description": "[Portability](/records/architecture/portability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Portability](/records/architecture/portability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-platform-migration", "title": "Platform Migration" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which staying portable across platforms forgoes optimizations specific to any one of them.", "term": "Definition", "wide": true }, { "description": "[Portability](/records/architecture/portability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with portability", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-platform-optimization", "title": "Platform Optimization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Binding code to one platform's APIs and assumptions, so it cannot run elsewhere without rewriting.", "term": "Definition", "wide": true }, { "description": "[Portability](/records/architecture/portability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Portability](/records/architecture/portability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-platform-specific-coupling", "title": "Platform-Specific Coupling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Deviating from a shared standard with proprietary extensions, breaking interoperability with conformant systems.", "term": "Definition", "wide": true }, { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Standards Compliance](/records/architecture/standards-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-proprietary-deviation", "title": "Proprietary Deviation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to switch the transport or wire protocol without changing core domain logic.", "term": "Definition", "wide": true }, { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-protocol-swap", "title": "Protocol Swap" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Domain logic written directly against a specific protocol, so changing the protocol means rewriting the core.", "term": "Definition", "wide": true }, { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-protocol-coupled-domain-logic", "title": "Protocol-Coupled Domain Logic" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which staying protocol-independent forgoes features unique to any one protocol.", "term": "Definition", "wide": true }, { "description": "[Protocol Independence](/records/architecture/protocol-independence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with protocol-independence", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-protocol-specific-features", "title": "Protocol-Specific Features" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to deploy with confidence because every environment behaves the same way.", "term": "Definition", "wide": true }, { "description": "[Environment Parity](/records/architecture/environment-parity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Environment Parity](/records/architecture/environment-parity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-deployment", "title": "Reliable Deployment" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to package an application and its runtime into one reproducible, portable unit.", "term": "Definition", "wide": true }, { "description": "[Containerization](/records/architecture/containerization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Containerization](/records/architecture/containerization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repeatable-runtime-packaging", "title": "Repeatable Runtime Packaging" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that secrets and sensitive configuration be stored and injected securely, never hardcoded.", "term": "Definition", "wide": true }, { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Configuration Externalization](/records/architecture/configuration-externalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-secure-config-handling", "title": "Secure Config Handling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "Environments each configured by hand into unique, unreproducible states, so what works in one fails in another.", "term": "Definition", "wide": true }, { "description": "[Environment Parity](/records/architecture/environment-parity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Environment Parity](/records/architecture/environment-parity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-snowflake-environments", "title": "Snowflake Environments" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Portability / Infrastructure / Deployment](/records/lexicon-category/portability-infrastructure-deployment)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "A system that records changes to files over time so any version can be recovered, compared, or audited.", "term": "Definition", "wide": true }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-version-control", "title": "Version Control" } ], "title": "Portability / Infrastructure / Deployment" }, { "icon": "bi-book", "id": "lexicon-category-processing-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that combines many items into one summary value, filed in an aggregators folder.", "term": "Definition", "wide": true }, { "description": "aggregators/daily-revenue.aggregator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-aggregator-tag", "title": "Aggregator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that reads a body of material and derives facts about it without judging it, filed in an analyzers folder.", "term": "Definition", "wide": true }, { "description": "analyzers/bundle-size.analyzer.ts", "term": "Example" }, { "description": "[Inspector Tag](/records/lexicon/inspector-tag): An analyzer derives facts across a body of material, while an inspector reports what one artifact holds.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-analyzer-tag", "title": "Analyzer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines how a value or a pose changes over a span of time, filed in an animations folder.", "term": "Definition", "wide": true }, { "description": "animations/walk-cycle.animation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-animation-tag", "title": "Animation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes the extents enclosing an object or a region, filed in a bounds folder.", "term": "Definition", "wide": true }, { "description": "bounds/viewport.bounds.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounds-tag", "title": "Bounds Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a shape used to detect when two objects touch, filed in a colliders folder.", "term": "Definition", "wide": true }, { "description": "colliders/capsule.collider.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-collider-tag", "title": "Collider Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides the order or the difference between two values, filed in a comparators folder.", "term": "Definition", "wide": true }, { "description": "comparators/semver.comparator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-comparator-tag", "title": "Comparator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that turns one representation into another of the same content, filed in a converters folder.", "term": "Definition", "wide": true }, { "description": "converters/temperature.converter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-converter-tag", "title": "Converter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a parametric path or response curve, filed in a curves folder.", "term": "Definition", "wide": true }, { "description": "curves/volume.curve.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-curve-tag", "title": "Curve Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes a cryptographic summary of content for integrity checks, filed in a digests folder.", "term": "Definition", "wide": true }, { "description": "digests/download.digest.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-digest-tag", "title": "Digest Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that maps linear progress onto a curve of acceleration and deceleration, filed in an easings folder.", "term": "Definition", "wide": true }, { "description": "easings/bounce.easing.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-easing-tag", "title": "Easing Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that pulls the records a transformation needs out of a larger source, filed in an extractors folder.", "term": "Definition", "wide": true }, { "description": "extractors/invoice-line.extractor.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extractor-tag", "title": "Extractor Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that keeps the items meeting a condition and drops the rest, filed in a filters folder.", "term": "Definition", "wide": true }, { "description": "filters/profanity.filter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-filter-tag", "title": "Filter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that arranges a group of agents in a shape relative to a leader, filed in a formations folder.", "term": "Definition", "wide": true }, { "description": "formations/wedge.formation.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formation-tag", "title": "Formation Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that lays data out as text in a target format such as Markdown, JSON or source code, filed in a formatters folder.", "term": "Definition", "wide": true }, { "description": "formatters/receipt.formatter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formatter-tag", "title": "Formatter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that produces values or files from a description of them, filed in a generators folder.", "term": "Definition", "wide": true }, { "description": "generators/api-client.generator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-generator-tag", "title": "Generator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that declares the productions a language is parsed by, filed in a grammars folder.", "term": "Definition", "wide": true }, { "description": "grammars/sql.grammar.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-grammar-tag", "title": "Grammar Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a regular division of space into cells, filed in a grids folder.", "term": "Definition", "wide": true }, { "description": "grids/chessboard.grid.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-grid-tag", "title": "Grid Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes fixed-size fingerprints of content, filed in a hashing folder.", "term": "Definition", "wide": true }, { "description": "hashing/password.hashing.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hashing-tag", "title": "Hashing Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that looks into one artifact and reports what it holds, filed in an inspectors folder.", "term": "Definition", "wide": true }, { "description": "inspectors/archive.inspector.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inspector-tag", "title": "Inspector Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that yields the members of a set one at a time, filed in an iterators folder.", "term": "Definition", "wide": true }, { "description": "iterators/directory-tree.iterator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-iterator-tag", "title": "Iterator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that creates, holds or rotates cryptographic keys, filed in a keys folder.", "term": "Definition", "wide": true }, { "description": "keys/signing.key.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-key-tag", "title": "Key Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that splits source text into tokens, filed in a lexers folder.", "term": "Definition", "wide": true }, { "description": "lexers/json.lexer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lexer-tag", "title": "Lexer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that maps the fields of one model onto another, filed in a mappers folder.", "term": "Definition", "wide": true }, { "description": "mappers/customer-row.mapper.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mapper-tag", "title": "Mapper Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that tests whether a value fits a shape and reports what it matched, filed in a matchers folder.", "term": "Definition", "wide": true }, { "description": "matchers/url-pattern.matcher.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-matcher-tag", "title": "Matcher Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that brings varied input to one canonical form before it is compared or stored, filed in a normalizers folder.", "term": "Definition", "wide": true }, { "description": "normalizers/phone-number.normalizer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-normalizer-tag", "title": "Normalizer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that builds a syntax tree from tokens by a grammar, filed in a parsers folder.", "term": "Definition", "wide": true }, { "description": "parsers/expression.parser.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parser-tag", "title": "Parser Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that splits a data set into parts processed or stored separately, filed in a partitions folder.", "term": "Definition", "wide": true }, { "description": "partitions/event-month.partition.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partition-tag", "title": "Partition Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that performs one full traversal of a program or a frame to transform or render it, filed in a passes folder.", "term": "Definition", "wide": true }, { "description": "passes/shadow.pass.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pass-tag", "title": "Pass Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that finds or defines a route between two points, filed in a paths folder.", "term": "Definition", "wide": true }, { "description": "paths/delivery.path.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-path-tag", "title": "Path Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that chains processing stages so each consumes the one before, filed in a pipelines folder.", "term": "Definition", "wide": true }, { "description": "pipelines/image-upload.pipeline.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pipeline-tag", "title": "Pipeline Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that applies one processing operation to each item that passes through it, filed in a processors folder.", "term": "Definition", "wide": true }, { "description": "processors/thumbnail.processor.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-processor-tag", "title": "Processor Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies random values from a declared and, where needed, seeded source, filed in a randomness folder.", "term": "Definition", "wide": true }, { "description": "randomness/dice.randomness.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-randomness-tag", "title": "Randomness Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that finds what a line through space hits first, filed in a raycasts folder.", "term": "Definition", "wide": true }, { "description": "raycasts/line-of-sight.raycast.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-raycast-tag", "title": "Raycast Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that reads a stored or external format into structure the system works with, filed in a readers folder.", "term": "Definition", "wide": true }, { "description": "readers/csv.reader.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reader-tag", "title": "Reader Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that removes or escapes the parts of untrusted input that could do harm, filed in a sanitizers folder.", "term": "Definition", "wide": true }, { "description": "sanitizers/comment-html.sanitizer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sanitizer-tag", "title": "Sanitizer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that receives the records a pipeline ends with, filed in a sinks folder.", "term": "Definition", "wide": true }, { "description": "sinks/warehouse.sink.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sink-tag", "title": "Sink Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that arranges a set of items in an order a comparison defines, filed in a sorters folder.", "term": "Definition", "wide": true }, { "description": "sorters/leaderboard.sorter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sorter-tag", "title": "Sorter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that produces the records a pipeline starts from, filed in a sources folder.", "term": "Definition", "wide": true }, { "description": "sources/sensor-feed.source.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-source-tag", "title": "Source Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one cell of a tiled world and what occupies it, filed in a tiles folder.", "term": "Definition", "wide": true }, { "description": "tiles/water.tile.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tile-tag", "title": "Tile Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes the path a moving object follows under its forces, filed in a trajectories folder.", "term": "Definition", "wide": true }, { "description": "trajectories/arrow.trajectory.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trajectory-tag", "title": "Trajectory Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that maps an input state to an output state, including a fix that rewrites a file, filed in a transformers folder.", "term": "Definition", "wide": true }, { "description": "transformers/import-sort.transformer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transformer-tag", "title": "Transformer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that interpolates a value between two endpoints over time, filed in a tweens folder.", "term": "Definition", "wide": true }, { "description": "tweens/menu-slide.tween.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tween-tag", "title": "Tween Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides whether its input is valid and reports why it is not, filed in a validators folder.", "term": "Definition", "wide": true }, { "description": "validators/password.validator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-validator-tag", "title": "Validator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that walks a syntax tree and acts on each node kind it meets, filed in a visitors folder.", "term": "Definition", "wide": true }, { "description": "visitors/unused-import.visitor.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-visitor-tag", "title": "Visitor Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Processing Concerns](/records/lexicon-category/processing-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that writes structure out to a stored or external format, filed in a writers folder.", "term": "Definition", "wide": true }, { "description": "writers/spreadsheet.writer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-writer-tag", "title": "Writer Tag" } ], "title": "Processing Concerns" }, { "icon": "bi-book", "id": "lexicon-category-product-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that makes an interface usable through assistive technology, filed in an accessibility folder.", "term": "Definition", "wide": true }, { "description": "accessibility/focus-trap.accessibility.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-accessibility-tag", "title": "Accessibility Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines reusable checks tests apply to outcomes, filed in an assertions folder.", "term": "Definition", "wide": true }, { "description": "assertions/money.assertion.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assertion-tag", "title": "Assertion Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that packs many images into one texture with the coordinates of each, filed in an atlases folder.", "term": "Definition", "wide": true }, { "description": "atlases/interface.atlas.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-atlas-tag", "title": "Atlas Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the viewpoint and projection a scene is seen through, filed in a cameras folder.", "term": "Definition", "wide": true }, { "description": "cameras/follow.camera.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-camera-tag", "title": "Camera Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds the inputs and expected outcomes one test runs, filed in a cases folder.", "term": "Definition", "wide": true }, { "description": "cases/login.case.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-case-tag", "title": "Case Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one command a command-line or chat surface accepts, filed in a commands folder.", "term": "Definition", "wide": true }, { "description": "commands/sync.command.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-command-tag", "title": "Command Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that renders one reusable piece of interface with its own inputs, filed in a components folder.", "term": "Definition", "wide": true }, { "description": "components/date-picker.component.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-component-tag", "title": "Component Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that measures which parts of a subject its tests reach, filed in a coverage folder.", "term": "Definition", "wide": true }, { "description": "coverage/branch.coverage.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coverage-tag", "title": "Coverage Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that replaces a collaborator in a test when no narrower double names its role, filed in a doubles folder.", "term": "Definition", "wide": true }, { "description": "doubles/clock.double.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-double-tag", "title": "Double Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that adds visual or audio feedback to an event without changing the state behind it, filed in an effects folder.", "term": "Definition", "wide": true }, { "description": "effects/screen-shake.effect.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-effect-tag", "title": "Effect Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that implements a collaborator in a simpler working form for tests, filed in a fakes folder.", "term": "Definition", "wide": true }, { "description": "fakes/payment-gateway.fake.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fake-tag", "title": "Fake Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that provides the known state or samples a test starts from, filed in a fixtures folder.", "term": "Definition", "wide": true }, { "description": "fixtures/sample-order.fixture.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fixture-tag", "title": "Fixture Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines one rendered image in a sequence and what it contains, filed in a frames folder.", "term": "Definition", "wide": true }, { "description": "frames/title-card.frame.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-frame-tag", "title": "Frame Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the mass tag for a file that holds shapes as vertices and faces, singular in both folder and tag.", "term": "Definition", "wide": true }, { "description": "geometry/terrain.geometry.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-geometry-tag", "title": "Geometry Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that sets up and drives the environment a subject is tested in, filed in a harnesses folder.", "term": "Definition", "wide": true }, { "description": "harnesses/device.harness.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-harness-tag", "title": "Harness Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that arranges regions of an interface without deciding their contents, filed in a layouts folder.", "term": "Definition", "wide": true }, { "description": "layouts/two-column.layout.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layout-tag", "title": "Layout Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines how a surface reflects light and which textures it uses, filed in a materials folder.", "term": "Definition", "wide": true }, { "description": "materials/brushed-metal.material.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-material-tag", "title": "Material Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that stands in for a collaborator and records how it was called, filed in a mocks folder.", "term": "Definition", "wide": true }, { "description": "mocks/mailer.mock.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mock-tag", "title": "Mock Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that simulates many small short-lived elements such as sparks or smoke, filed in a particles folder.", "term": "Definition", "wide": true }, { "description": "particles/campfire.particle.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-particle-tag", "title": "Particle Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that writes a command surface's output to a terminal, filed in a printers folder.", "term": "Definition", "wide": true }, { "description": "printers/progress-bar.printer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-printer-tag", "title": "Printer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that asks a participant for input and validates the answer, filed in a prompts folder.", "term": "Definition", "wide": true }, { "description": "prompts/delete-confirmation.prompt.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prompt-tag", "title": "Prompt Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file of authored knowledge a reader consults, such as a guide or a note, filed in a references folder.", "term": "Definition", "wide": true }, { "description": "references/style-guide.reference.md", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reference-tag", "title": "Reference Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that draws frames to a display from a scene or a model, filed in a renderers folder.", "term": "Definition", "wide": true }, { "description": "renderers/terrain.renderer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-renderer-tag", "title": "Renderer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that returns a removed participant or object to the world under stated rules, filed in a respawn folder.", "term": "Definition", "wide": true }, { "description": "respawn/player.respawn.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-respawn-tag", "title": "Respawn Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that discovers and runs a set of tests or tasks and collects their results, filed in a runners folder.", "term": "Definition", "wide": true }, { "description": "runners/benchmark.runner.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runner-tag", "title": "Runner Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a program the graphics processor runs per vertex or per pixel, filed in a shaders folder.", "term": "Definition", "wide": true }, { "description": "shaders/water.shader.glsl", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shader-tag", "title": "Shader Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a two-dimensional image drawn and moved as one object, filed in a sprites folder.", "term": "Definition", "wide": true }, { "description": "sprites/hero.sprite.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sprite-tag", "title": "Sprite Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that wraps a real collaborator and records its calls, filed in a spies folder.", "term": "Definition", "wide": true }, { "description": "spies/logger.spy.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-spy-tag", "title": "Spy Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that holds the user-visible text a surface displays, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "strings/checkout.strings.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strings-tag", "title": "Strings Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that returns fixed answers in place of a collaborator, filed in a stubs folder.", "term": "Definition", "wide": true }, { "description": "stubs/weather-api.stub.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stub-tag", "title": "Stub Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds the presentation rules for one surface, filed in a styles folder.", "term": "Definition", "wide": true }, { "description": "styles/button.style.css", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-style-tag", "title": "Style Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that groups related test cases under one setup, filed in a suites folder.", "term": "Definition", "wide": true }, { "description": "suites/checkout.suite.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-suite-tag", "title": "Suite Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that signals an action before it lands so a participant can react, filed in a telegraphs folder.", "term": "Definition", "wide": true }, { "description": "telegraphs/ground-slam.telegraph.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-telegraph-tag", "title": "Telegraph Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a shape with slots that are filled to produce an output, filed in a templates folder.", "term": "Definition", "wide": true }, { "description": "templates/invoice-email.template.html", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-template-tag", "title": "Template Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the compound marker for a file that exercises another file and asserts on the outcome, which is exempt from the naming grammar and placed in its subject's mirrored concern folder.", "term": "Definition", "wide": true }, { "description": "stores/cart.store.test.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Tests](/records/lexicon/tests), [Compound Marker](/records/lexicon/compound-marker)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-test-tag", "title": "Test Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that selects one coherent set of visual values for a whole interface, filed in a themes folder.", "term": "Definition", "wide": true }, { "description": "themes/midnight.theme.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-theme-tag", "title": "Theme Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the collection tag for a file that declares named design values such as colors and spacing, plural in both folder and tag.", "term": "Definition", "wide": true }, { "description": "tokens/spacing.tokens.css", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tokens-tag", "title": "Tokens Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that renders one screen or page from the state it is given, filed in a views folder.", "term": "Definition", "wide": true }, { "description": "views/settings.view.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-view-tag", "title": "View Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines the region of a display a camera draws into, filed in a viewports folder.", "term": "Definition", "wide": true }, { "description": "viewports/minimap.viewport.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-viewport-tag", "title": "Viewport Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Product Concerns](/records/lexicon-category/product-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that renders one interactive control, filed in a widgets folder.", "term": "Definition", "wide": true }, { "description": "widgets/volume-slider.widget.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-widget-tag", "title": "Widget Tag" } ], "title": "Product Concerns" }, { "icon": "bi-book", "id": "lexicon-category-quality-attributes", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Enforcement Core](/records/layer/enforcement-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which an implementation conforms to its intended architectural rules, boundaries, and constraints.", "term": "Definition", "wide": true }, { "description": "[Dependency Graph](/records/architecture/dependency-graph), [Static Analysis](/records/architecture/static-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dependency Graph](/records/architecture/dependency-graph), [Static Analysis](/records/architecture/static-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-architecture-compliance", "title": "Architecture Compliance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The proportion of time a system is operational and able to serve requests.", "term": "Definition", "wide": true }, { "description": "[Control Plane](/records/architecture/control-plane), [Leader Election](/records/architecture/leader-election), [Consensus](/records/architecture/consensus), [Eventual Consistency](/records/architecture/eventual-consistency), [Fail Safe](/records/architecture/fail-safe), [Fail Secure](/records/architecture/fail-secure), [Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing), [Failover](/records/architecture/failover), [Replication](/records/architecture/replication), [Blue-Green Deployment](/records/architecture/blue-green-deployment), [Single Source of Truth](/records/architecture/single-source-of-truth), [Consistency](/records/architecture/consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with control-plane, the tension resolution with leader-election, the tension resolution with consensus, [Eventual Consistency](/records/architecture/eventual-consistency), the tension resolution with fail-safe, the tension resolution with fail-secure, [Horizontal Scaling](/records/architecture/horizontal-scaling), [Load Balancing](/records/architecture/load-balancing), [Failover](/records/architecture/failover), [Replication](/records/architecture/replication), [Blue-Green Deployment](/records/architecture/blue-green-deployment), the tension resolution with single-source-of-truth, the tension resolution with consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-availability", "title": "Availability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The degree of interdependence and intricacy that makes a system harder to reason about and change.", "term": "Definition", "wide": true }, { "description": "[Resilience](/records/architecture/resilience), [Flyweight Pattern](/records/architecture/flyweight-pattern), [Concurrency](/records/architecture/concurrency), [Defense in Depth](/records/architecture/defense-in-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with resilience, the tension resolution with flyweight-pattern, the tension resolution with concurrency, the tension resolution with defense-in-depth", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complexity", "title": "Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The additional cost incurred to synchronize and coordinate concurrent or distributed units of work.", "term": "Definition", "wide": true }, { "description": "[Parallelism](/records/architecture/parallelism), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with parallelism, the tension resolution with fan-out-fan-in", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordination-overhead", "title": "Coordination Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The accuracy, consistency, and validity of data maintained over its entire lifecycle.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown), [Database Normalization](/records/architecture/database-normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown), [Database Normalization](/records/architecture/database-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-integrity", "title": "Data Integrity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Observability](/records/layer/observability)" ], "kind": "list" }, { "entries": [ { "description": "The ease with which a fault can be located and understood from a system's observable behavior.", "term": "Definition", "wide": true }, { "description": "[Encapsulation](/records/architecture/encapsulation), [Event-Driven Architecture](/records/architecture/event-driven-architecture), [Metadata-Driven Design](/records/architecture/metadata-driven-design), [Metaprogramming](/records/architecture/metaprogramming), [Observability](/records/architecture/observability), [Traceability](/records/architecture/traceability), [Observer Pattern](/records/architecture/observer-pattern)", "term": "Referenced by" }, { "description": "[Traceability](/records/architecture/traceability): Debuggability is locating and understanding a fault, while traceability is following one request or change end to end.", "term": "Distinct from" }, { "description": "[Auditability](/records/architecture/auditability): Debuggability serves finding faults, while auditability serves accounting for sensitive actions.", "term": "Distinct from" }, { "description": "[Strong Consistency](/records/lexicon/strong-consistency): Debuggability is how easily a fault is understood, while strong consistency is every read seeing the latest write.", "term": "Distinct from" }, { "description": "[Ordering](/records/lexicon/ordering): Debuggability is understanding faults, while ordering is processing events in one defined sequence.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with encapsulation, the tension resolution with event-driven-architecture, the tension resolution with metadata-driven-design, the tension resolution with metaprogramming, [Observability](/records/architecture/observability), [Traceability](/records/architecture/traceability), the tension resolution with observer-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-debuggability", "title": "Debuggability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ease with which a system's components, capabilities, or endpoints can be found and understood.", "term": "Definition", "wide": true }, { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Describing API](/records/architecture/self-describing-api), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal), [Mirrored Test Placement](/records/architecture/mirrored-test-placement), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Referenced by" }, { "description": "[Glob Resolvability](/records/lexicon/glob-resolvability): Discoverability is how easily anything in a system is found and understood, while glob resolvability is one pattern collecting a whole concern.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Self-Describing Architecture](/records/architecture/self-describing-architecture), [Self-Describing API](/records/architecture/self-describing-api), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal), [Mirrored Test Placement](/records/architecture/mirrored-test-placement), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-discoverability", "title": "Discoverability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a failure in one component is contained and prevented from cascading to others.", "term": "Definition", "wide": true }, { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue), [Timeout Pattern](/records/architecture/timeout-pattern), [Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue), [Timeout Pattern](/records/architecture/timeout-pattern), [Bulkhead Pattern](/records/architecture/bulkhead-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fault-isolation", "title": "Fault Isolation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The ease with which a system can be corrected, adapted, and extended over its lifetime.", "term": "Definition", "wide": true }, { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Design Review](/records/architecture/design-review), [Pattern Consistency](/records/architecture/pattern-consistency), [Performance Engineering](/records/architecture/performance-engineering), [Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" }, { "description": "[Pattern Consistency](/records/architecture/pattern-consistency): Maintainability is the ease of changing a system, while pattern consistency is one problem solved one way, which helps it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Separation of Concerns](/records/architecture/separation-of-concerns), [Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Design Review](/records/architecture/design-review), [Pattern Consistency](/records/architecture/pattern-consistency), the tension resolution with performance-engineering, [Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-maintainability", "title": "Maintainability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The additional cost of translating data or calls between two differing representations or models.", "term": "Definition", "wide": true }, { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with anti-corruption-layer, the tension resolution with adapter-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mapping-overhead", "title": "Mapping Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The ongoing effort and resource cost of deploying, running, and maintaining a system in production.", "term": "Definition", "wide": true }, { "description": "[Dead-Letter Queue](/records/architecture/dead-letter-queue), [Service-Oriented Architecture](/records/architecture/service-oriented-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dead-letter-queue, the tension resolution with service-oriented-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-overhead", "title": "Operational Overhead" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Causality Core](/records/layer/causality-core)" ], "kind": "list" }, { "entries": [ { "description": "The guarantee that events or messages are processed in a well-defined, consistent sequence.", "term": "Definition", "wide": true }, { "description": "[Competing Consumers](/records/architecture/competing-consumers), [Observer Pattern](/records/architecture/observer-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with competing-consumers, the tension resolution with observer-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordering", "title": "Ordering" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The condition in which a system continues serving a subset of its functions while some components are unavailable.", "term": "Definition", "wide": true }, { "description": "[Graceful Degradation](/records/architecture/graceful-degradation), [Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Degradation](/records/architecture/graceful-degradation), [Fallback Pattern](/records/architecture/fallback-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partial-availability", "title": "Partial Availability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The speed, throughput, and resource efficiency with which a system performs its work.", "term": "Definition", "wide": true }, { "description": "[Parallelism](/records/architecture/parallelism), [Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parallelism](/records/architecture/parallelism), the tension resolution with concurrency-control", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-performance", "title": "Performance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The difficulty of understanding, maintaining, and reasoning about a policy as its rules multiply.", "term": "Definition", "wide": true }, { "description": "[Authorization](/records/architecture/authorization), [Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with authorization, the tension resolution with attribute-based-access-control", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-policy-complexity", "title": "Policy Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The ease with which source code can be read and understood by a developer.", "term": "Definition", "wide": true }, { "description": "[Homoiconicity](/records/architecture/homoiconicity), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with homoiconicity, [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-readability", "title": "Readability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system performs its required functions correctly and consistently over time.", "term": "Definition", "wide": true }, { "description": "[Monitoring](/records/architecture/monitoring), [Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" }, { "description": "[Data Integrity](/records/lexicon/data-integrity): Reliability is functions performing correctly over time, while data integrity is the data staying accurate and valid over its life.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Monitoring](/records/architecture/monitoring), [Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliability", "title": "Reliability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Resource Core](/records/layer/resource-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system accomplishes its work using minimal computational resources.", "term": "Definition", "wide": true }, { "description": "[Performance Engineering](/records/architecture/performance-engineering), [Optimization](/records/architecture/optimization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Performance Engineering](/records/architecture/performance-engineering), [Optimization](/records/architecture/optimization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-efficiency", "title": "Resource Efficiency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The property that an operation can be retried without producing duplicate or inconsistent effects.", "term": "Definition", "wide": true }, { "description": "[Asynchronous Communication](/records/architecture/asynchronous-communication), [Idempotency](/records/architecture/idempotency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Asynchronous Communication](/records/architecture/asynchronous-communication), [Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retry-safety", "title": "Retry Safety" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system continues to operate correctly under invalid input, stress, or unexpected conditions.", "term": "Definition", "wide": true }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing), [Defensive Programming](/records/architecture/defensive-programming), [Prompt Engineering](/records/architecture/prompt-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Property-Based Testing](/records/architecture/property-based-testing), [Defensive Programming](/records/architecture/defensive-programming), the tension resolution with prompt-engineering", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-robustness", "title": "Robustness" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system protects its data and behavior from unauthorized access, misuse, or attack.", "term": "Definition", "wide": true }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility), [Centralized Authentication](/records/architecture/centralized-authentication), [Static Analysis](/records/architecture/static-analysis), [Code Review](/records/architecture/code-review), [Model Safety](/records/architecture/model-safety), [Proxy Pattern](/records/architecture/proxy-pattern), [Rate Limiting](/records/architecture/rate-limiting), [Plugin Architecture](/records/architecture/plugin-architecture), [Input Validation](/records/architecture/input-validation), [Privacy by Design](/records/architecture/privacy-by-design), [Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Referenced by" }, { "description": "[Model Safety](/records/architecture/model-safety): Security protects data and behavior from attack, while model safety prevents a model's harmful inputs, outputs and actions.", "term": "Distinct from" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility): Security limits what can reach a system, while runtime extensibility opens it to new capability as it runs.", "term": "Distinct from" }, { "description": "[Quality](/records/lexicon/quality): Security is one expectation of a system, while quality is how far it meets all of them.", "term": "Distinct from" }, { "description": "[Architecture Compliance](/records/lexicon/architecture-compliance): Security is protection from misuse, while architecture compliance is conformance to the intended structure.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with runtime-extensibility, [Centralized Authentication](/records/architecture/centralized-authentication), [Static Analysis](/records/architecture/static-analysis), [Code Review](/records/architecture/code-review), [Model Safety](/records/architecture/model-safety), [Proxy Pattern](/records/architecture/proxy-pattern), [Rate Limiting](/records/architecture/rate-limiting), the tension resolution with plugin-architecture, [Input Validation](/records/architecture/input-validation), [Privacy by Design](/records/architecture/privacy-by-design), [Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-security", "title": "Security" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The absence of unnecessary structure, keeping a system easy to understand and change.", "term": "Definition", "wide": true }, { "description": "[Do Not Repeat Yourself (DRY)](/records/architecture/duplicate-code), [Abstraction](/records/architecture/abstraction), [Open/Closed Principle (OCP)](/records/architecture/open-closed), [Error Handling](/records/architecture/error-handling), [Minimum Viable Architecture](/records/architecture/minimum-viable-architecture), [First-Principles Design](/records/architecture/first-principles-design), [Command Pattern](/records/architecture/command-pattern), [Iterator Pattern](/records/architecture/iterator-pattern), [Factory Pattern](/records/architecture/factory-pattern), [Scalability](/records/architecture/scalability), [Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Referenced by" }, { "description": "[Locality of Behavior](/records/lexicon/locality-of-behavior): Simplicity is the absence of unneeded structure, while locality of behavior keeps related behavior together even at the cost of some duplication.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with duplicate-code, the tension resolution with abstraction, the tension resolution with open-closed, the tension resolution with error-handling, [Minimum Viable Architecture](/records/architecture/minimum-viable-architecture), [First-Principles Design](/records/architecture/first-principles-design), the tension resolution with command-pattern, the tension resolution with iterator-pattern, the tension resolution with factory-pattern, the tension resolution with scalability, [Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-simplicity", "title": "Simplicity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The guarantee that whole classes of errors are caught at compile time, before code runs.", "term": "Definition", "wide": true }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding), [Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Referenced by" }, { "description": "[Security/Debugging](/records/lexicon/security-debugging): Static safety catches errors before code runs, while the security and debugging cost is what generating code at runtime adds.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dynamic-binding, the tension resolution with runtime-code-generation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-static-safety", "title": "Static Safety" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a component can be replaced by another honoring the same contract without breaking clients.", "term": "Definition", "wide": true }, { "description": "[Substitutability](/records/algorithms/substitutability)", "term": "Contract" }, { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Polymorphism](/records/architecture/polymorphism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Polymorphism](/records/architecture/polymorphism)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-substitutability", "title": "Substitutability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a team can make and deliver decisions independently, without cross-team coordination.", "term": "Definition", "wide": true }, { "description": "[Reference Architecture](/records/architecture/reference-architecture), [Monolith Architecture](/records/architecture/monolith-architecture)", "term": "Referenced by" }, { "description": "[Independent Scaling](/records/lexicon/independent-scaling): Team autonomy is teams deciding without coordination, while independent scaling is parts of the system growing separately.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with reference-architecture, the tension resolution with monolith-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-team-autonomy", "title": "Team Autonomy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The effort required to set up, learn, and maintain the tools a technique or approach depends on.", "term": "Definition", "wide": true }, { "description": "[Infrastructure as Code](/records/architecture/infrastructure-as-code), [Statecharts](/records/architecture/statecharts)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with infrastructure-as-code, the tension resolution with statecharts", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tooling-complexity", "title": "Tooling Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Quality Attributes](/records/lexicon-category/quality-attributes)", "Layer: [Human Factors](/records/layer/human-factors)" ], "kind": "list" }, { "entries": [ { "description": "The overall quality of a user's interaction with a system, including responsiveness, clarity, and ease of use.", "term": "Definition", "wide": true }, { "description": "UX", "term": "Aliases" }, { "description": "[Latency](/records/architecture/latency), [Rate Limiting](/records/architecture/rate-limiting), [Authentication](/records/architecture/authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Latency](/records/architecture/latency), the tension resolution with rate-limiting, the tension resolution with authentication", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-user-experience", "title": "User Experience" } ], "title": "Quality Attributes" }, { "icon": "bi-book", "id": "lexicon-category-refused-tags", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file pattern-memory or agent-memory, where the memory tag already covers what an agent remembers between steps.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "agent-memories/scout.agent-memory.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "memory/scout.memory.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Memory Tag](/records/lexicon/memory-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-agent-memory-as-a-tag", "title": "Agent Memory as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file weapon-pattern or attack-pattern, where the behavior tag covers a file that decides and the specification tag one that only declares.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "attack-patterns/boss.attack-pattern.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "behaviors/boss.behavior.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Behavior Tag](/records/lexicon/behavior-tag), [Specification Tag](/records/lexicon/specification-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-attack-pattern-as-a-tag", "title": "Attack Pattern as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file batcher, where the batching tag already covers a file that groups small operations into larger ones.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "batchers/draw-call.batcher.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "batching/draw-call.batching.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Batching Tag](/records/lexicon/batching-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-batcher-as-a-tag", "title": "Batcher as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file blueprint or archetype, where the specification tag covers a file that declares a rule and the template tag covers one that declares a shape.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "archetypes/enemy.archetype.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "templates/enemy.template.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Specification Tag](/records/lexicon/specification-tag), [Template Tag](/records/lexicon/template-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blueprint-or-archetype-as-a-tag", "title": "Blueprint or Archetype as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file checker or linter, where the validator tag covers a file that decides whether its input is valid.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "checkers/spelling.checker.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "validators/spelling.validator.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Validator Tag](/records/lexicon/validator-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-checker-or-linter-as-a-tag", "title": "Checker or Linter as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file condition or phase-condition, where the predicate tag already covers a file that answers yes or no.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "conditions/boss-phase.condition.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "predicates/boss-phase.predicate.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Predicate Tag](/records/lexicon/predicate-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-condition-as-a-tag", "title": "Condition as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a slider or a toggle control by its kind of control, where the widget tag covers every interactive control.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "sliders/brightness.slider.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "widgets/brightness.widget.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Widget Tag](/records/lexicon/widget-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-control-widget-as-a-tag", "title": "Control Widget as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file cooldown or throttle, where the throttling tag covers limiting how often something runs and the timer tag covers running it after a delay.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "cooldowns/dash.cooldown.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "throttling/dash.throttling.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Throttling Tag](/records/lexicon/throttling-tag), [Timer Tag](/records/lexicon/timer-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cooldown-as-a-tag", "title": "Cooldown as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file fixer, healer or repairer, where the transformer tag covers a file that maps an input state to an output state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "fixers/import-order.fixer.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "transformers/import-order.transformer.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Transformer Tag](/records/lexicon/transformer-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fixer-or-healer-as-a-tag", "title": "Fixer or Healer as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file gate, which names a decision rather than a thing, where the predicate and validator tags cover the decision it makes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "gates/age.gate.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "predicates/age.predicate.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Predicate Tag](/records/lexicon/predicate-tag), [Validator Tag](/records/lexicon/validator-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-gate-as-a-tag", "title": "Gate as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file doc, guide or note, where the reference tag covers authored knowledge a reader consults.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "guides/deployment.guide.md", "kind": "code", "language": "text", "title": "Before" }, { "code": "references/deployment.reference.md", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Reference Tag](/records/lexicon/reference-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guide-or-note-as-a-tag", "title": "Guide or Note as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file handler, which fits every role, where the processor tag covers applying an operation to each item and the coordinator tag covers driving collaborators.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "handlers/upload.handler.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "processors/upload.processor.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Processor Tag](/records/lexicon/processor-tag), [Coordinator Tag](/records/lexicon/coordinator-tag), [Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-handler-as-a-tag", "title": "Handler as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file ids, id-table or symbol-table, where the constants collection tag covers a file of fixed named values.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "id-tables/country.id-table.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "constants/country.constants.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Constants Tag](/records/lexicon/constants-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-id-table-as-a-tag", "title": "Id Table as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file index, which overlaps cache and registry, where the registry tag covers a lookup over known members.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "indexes/product.index.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "registries/product.registry.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Registry Tag](/records/lexicon/registry-tag), [Vocabulary Inflation](/records/lexicon/vocabulary-inflation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-index-as-a-tag", "title": "Index as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file feedback, juice or screenshake, where the effect tag covers feedback that leaves the state behind it unchanged.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "screenshakes/explosion.screenshake.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "effects/explosion.effect.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Effect Tag](/records/lexicon/effect-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-juice-or-screenshake-as-a-tag", "title": "Juice or Screenshake as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file keybinding or control-scheme, where the binding tag already covers a file that ties a name to what it resolves to.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "keybindings/editor.keybinding.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "bindings/editor.binding.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Binding Tag](/records/lexicon/binding-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-keybinding-as-a-tag", "title": "Keybinding as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a simulation's main loop or its tick as its own concern, where the engine tag covers the file that runs the loop and the step tag covers one advance.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "ticks/physics.tick.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "steps/physics.step.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Engine Tag](/records/lexicon/engine-tag), [Step Tag](/records/lexicon/step-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-loop-or-tick-as-a-tag", "title": "Loop or Tick as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file manager, which names a stature rather than a role, where the coordinator tag covers a file that owns a lifecycle and the service tag one that offers a stateful capability.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "managers/audio.manager.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "coordinators/audio.coordinator.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Coordinator Tag](/records/lexicon/coordinator-tag), [Service Tag](/records/lexicon/service-tag), [Saturated Role Tag](/records/lexicon/saturated-role-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manager-as-a-tag", "title": "Manager as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file object-pool, where the pool tag already covers keeping reusable instances.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "object-pools/enemy.object-pool.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "pools/enemy.pool.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Pool Tag](/records/lexicon/pool-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-object-pool-as-a-tag", "title": "Object Pool as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file page-feature or plug-in behavior, where the extension and plugin tags cover capability added to a host.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "page-features/comments.page-feature.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "extensions/comments.extension.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Extension Tag](/records/lexicon/extension-tag), [Plugin Tag](/records/lexicon/plugin-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-page-feature-as-a-tag", "title": "Page Feature as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file page-script, where the entrypoint tag covers the file a runtime starts from.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "page-scripts/pricing.page-script.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "entrypoints/pricing.entrypoint.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Entrypoint Tag](/records/lexicon/entrypoint-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-page-script-as-a-tag", "title": "Page Script as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file particle-emitter, where the emitter tag already covers a file that produces output for others to receive.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "particle-emitters/smoke.particle-emitter.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "emitters/smoke.emitter.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Emitter Tag](/records/lexicon/emitter-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-particle-emitter-as-a-tag", "title": "Particle Emitter as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file after one lifecycle moment such as pause, boot or teardown, where the lifecycle tag covers how a component starts and stops.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "boot/game.boot.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "lifecycle/game.lifecycle.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Lifecycle Tag](/records/lexicon/lifecycle-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pause-or-boot-as-a-tag", "title": "Pause or Boot as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file plan, where the specification tag covers a file that declares a required end state.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "plans/launch.plan.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "specifications/launch.specification.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Specification Tag](/records/lexicon/specification-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plan-as-a-tag", "title": "Plan as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file preloader or asset-loader, where the loader tag already covers reading a resource into memory.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "preloaders/level-assets.preloader.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "loaders/level-assets.loader.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Loader Tag](/records/lexicon/loader-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-preloader-as-a-tag", "title": "Preloader as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file savegame or autosave, where the persistence tag covers saving state and the store tag covers holding it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "savegames/campaign.savegame.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "persistence/campaign.persistence.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Persistence Tag](/records/lexicon/persistence-tag), [Store Tag](/records/lexicon/store-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-savegame-as-a-tag", "title": "Savegame as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file scanner, which overlaps reporter and inspector, where the analyzer and inspector tags cover a file that reads material and derives facts from it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "scanners/dependency.scanner.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "analyzers/dependency.analyzer.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Analyzer Tag](/records/lexicon/analyzer-tag), [Inspector Tag](/records/lexicon/inspector-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scanner-as-a-tag", "title": "Scanner as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file endscreen, hud-panel or page, where the view tag covers a file that renders one screen.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "pages/leaderboard.page.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "views/leaderboard.view.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[View Tag](/records/lexicon/view-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-screen-or-page-as-a-tag", "title": "Screen or Page as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a spatial hash or a quadtree as a domain concern, where a lookup structure over known members takes the registry tag.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "quadtrees/enemy.quadtree.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "registries/enemy.registry.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Registry Tag](/records/lexicon/registry-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-spatial-index-as-a-tag", "title": "Spatial Index as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file spawner or prefab, where the factory tag already covers a file that constructs instances.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "spawners/enemy.spawner.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "factories/enemy.factory.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Factory Tag](/records/lexicon/factory-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-spawner-or-prefab-as-a-tag", "title": "Spawner or Prefab as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file strategy or difficulty-policy, where the policy tag already covers a file that chooses among behaviors by a rule.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "strategies/difficulty.strategy.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "policies/difficulty.policy.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Policy Tag](/records/lexicon/policy-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strategy-as-a-tag", "title": "Strategy as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file thread, where the worker tag covers running work apart from the caller.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "threads/image-resize.thread.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "workers/image-resize.worker.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Worker Tag](/records/lexicon/worker-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-thread-as-a-tag", "title": "Thread as a Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Refused Tags](/records/lexicon-category/refused-tags)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Tagging a file walker or crawler, where the iterator tag covers a file that yields the members of a set.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "code": "crawlers/link.crawler.ts", "kind": "code", "language": "text", "title": "Before" }, { "code": "iterators/link.iterator.ts", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses the word in the concern slot because no declaration admits it", "term": "Checked by" }, { "description": "Every filename that would carry the refused word, and the covering tags each refusal names", "term": "Population" }, { "description": "A verdict stands until a covering tag is renamed or removed, or the refused word is admitted by an approved edit", "term": "Freshness" }, { "description": "The lint run fails a filename carrying the refused word as its concern", "term": "Refusal" }, { "description": "Each refused word resolved through its covering-tag edges, which the resolution gate follows", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose concern slot holds an undeclared word and passes a file carrying a declared tag", "term": "Evidence" }, { "description": "The covering tags, which a refused word resolves to, so admitting the word is an approved edit to the vocabulary", "term": "Authoritative side" }, { "description": "[Iterator Tag](/records/lexicon/iterator-tag)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-walker-or-crawler-as-a-tag", "title": "Walker or Crawler as a Tag" } ], "title": "Refused Tags" }, { "icon": "bi-book", "id": "lexicon-category-runtime-concerns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that switches a prepared component into its active state when its trigger arrives, filed in an activators folder.", "term": "Definition", "wide": true }, { "description": "activators/voice-command.activator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-activator-tag", "title": "Activator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that assembles the system's parts in order before it serves anything, filed in a bootstrappers folder.", "term": "Definition", "wide": true }, { "description": "bootstrappers/api-server.bootstrapper.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bootstrapper-tag", "title": "Bootstrapper Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that answers which days count, such as working days and holidays, filed in a calendars folder.", "term": "Definition", "wide": true }, { "description": "calendars/business-day.calendar.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-calendar-tag", "title": "Calendar Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries messages between two parties of a concurrent program, filed in a channels folder.", "term": "Definition", "wide": true }, { "description": "channels/progress.channel.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-channel-tag", "title": "Channel Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that removes leftover state a finished operation leaves behind, filed in a cleanup folder.", "term": "Definition", "wide": true }, { "description": "cleanup/temp-upload.cleanup.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cleanup-tag", "title": "Cleanup Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that supplies the current time through one replaceable source, filed in a clocks folder.", "term": "Definition", "wide": true }, { "description": "clocks/system.clock.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-clock-tag", "title": "Clock Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds a schedule written as a cron expression, filed in a crons folder.", "term": "Definition", "wide": true }, { "description": "crons/backup-rotation.cron.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cron-tag", "title": "Cron Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that carries the absolute time by which a piece of work must finish, filed in a deadlines folder.", "term": "Definition", "wide": true }, { "description": "deadlines/render-frame.deadline.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deadline-tag", "title": "Deadline Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defers an action by a computed amount of time, filed in a delays folder.", "term": "Definition", "wide": true }, { "description": "delays/retry-backoff.delay.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-delay-tag", "title": "Delay Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that releases the resources an object holds when the object is no longer used, filed in a disposal folder.", "term": "Definition", "wide": true }, { "description": "disposal/gpu-texture.disposal.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-disposal-tag", "title": "Disposal Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that lets in-flight work finish while refusing new work before a stop, filed in a draining folder.", "term": "Definition", "wide": true }, { "description": "draining/websocket.draining.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-draining-tag", "title": "Draining Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs the central loop advancing a system's state, filed in an engines folder.", "term": "Definition", "wide": true }, { "description": "engines/physics.engine.ts", "term": "Example" }, { "description": "[Step Tag](/records/lexicon/step-tag): An engine runs the loop that advances a system, while a step is one advance within it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-engine-tag", "title": "Engine Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file a runtime starts from, which reads its arguments and hands control to the code behind it, filed in an entrypoints folder.", "term": "Definition", "wide": true }, { "description": "entrypoints/cli.entrypoint.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-entrypoint-tag", "title": "Entrypoint Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that computes the value of an expression or a rule against given inputs, filed in an evaluators folder.", "term": "Definition", "wide": true }, { "description": "evaluators/pricing-rule.evaluator.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evaluator-tag", "title": "Evaluator Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs submitted work on the resources it manages, filed in an executors folder.", "term": "Definition", "wide": true }, { "description": "executors/thread-pool.executor.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-executor-tag", "title": "Executor Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs last work on an object as the runtime reclaims it, filed in a finalizers folder.", "term": "Definition", "wide": true }, { "description": "finalizers/file-handle.finalizer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-finalizer-tag", "title": "Finalizer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a handle to a result that is not computed yet, filed in a futures folder.", "term": "Definition", "wide": true }, { "description": "futures/quote.future.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-future-tag", "title": "Future Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines an opaque reference to a resource another part of the system owns, filed in a handles folder.", "term": "Definition", "wide": true }, { "description": "handles/window.handle.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-handle-tag", "title": "Handle Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that keeps items ordered so the highest-priority one is always taken first, filed in a heaps folder.", "term": "Definition", "wide": true }, { "description": "heaps/job-priority.heap.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-heap-tag", "title": "Heap Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that prepares one component's starting state, filed in an initializers folder.", "term": "Definition", "wide": true }, { "description": "initializers/audio-engine.initializer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-initializer-tag", "title": "Initializer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that executes a program by walking its representation directly, filed in an interpreters folder.", "term": "Definition", "wide": true }, { "description": "interpreters/bytecode.interpreter.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interpreter-tag", "title": "Interpreter Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that governs how a component starts, pauses, resumes and stops, filed in a lifecycle folder.", "term": "Definition", "wide": true }, { "description": "lifecycle/game-session.lifecycle.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lifecycle-tag", "title": "Lifecycle Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs at one named point of a component's lifecycle, filed in a lifecycle-hooks folder.", "term": "Definition", "wide": true }, { "description": "lifecycle-hooks/editor-mount.lifecycle-hook.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lifecycle-hook-tag", "title": "Lifecycle-Hook Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds the messages addressed to one actor until it processes them, filed in a mailboxes folder.", "term": "Definition", "wide": true }, { "description": "mailboxes/chat-room.mailbox.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mailbox-tag", "title": "Mailbox Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds what an agent or a process remembers between steps, filed in a memory folder.", "term": "Definition", "wide": true }, { "description": "memory/conversation.memory.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-memory-tag", "title": "Memory Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a named span of calendar time such as a billing month, filed in a periods folder.", "term": "Definition", "wide": true }, { "description": "periods/fiscal-quarter.period.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-period-tag", "title": "Period Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that connects one stage's output directly to the next stage's input as a byte or item stream, filed in a pipes folder.", "term": "Definition", "wide": true }, { "description": "pipes/gzip.pipe.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pipe-tag", "title": "Pipe Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that keeps reusable instances and lends them out instead of creating new ones, filed in a pools folder.", "term": "Definition", "wide": true }, { "description": "pools/bullet.pool.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pool-tag", "title": "Pool Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that settles an asynchronous result once, as fulfilled or rejected, filed in a promises folder.", "term": "Definition", "wide": true }, { "description": "promises/geolocation.promise.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-promise-tag", "title": "Promise Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that holds items in arrival order until a consumer takes them, filed in a queues folder.", "term": "Definition", "wide": true }, { "description": "queues/email.queue.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-queue-tag", "title": "Queue Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that defines a rule for repeating an event in time, filed in a recurrences folder.", "term": "Definition", "wide": true }, { "description": "recurrences/weekly-standup.recurrence.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-recurrence-tag", "title": "Recurrence Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that provides the environment other code executes inside, filed in a runtimes folder.", "term": "Definition", "wide": true }, { "description": "runtimes/sandbox.runtime.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-tag", "title": "Runtime Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that decides when each piece of work runs, filed in a schedulers folder.", "term": "Definition", "wide": true }, { "description": "schedulers/report.scheduler.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scheduler-tag", "title": "Scheduler Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that stops a process in an order that loses no committed work, filed in a shutdown folder.", "term": "Definition", "wide": true }, { "description": "shutdown/order-worker.shutdown.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shutdown-tag", "title": "Shutdown Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs the work a process must finish before it accepts any, filed in a startup folder.", "term": "Definition", "wide": true }, { "description": "startup/license-check.startup.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-startup-tag", "title": "Startup Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that removes what a setup created, such as fixtures or temporary resources, filed in a teardown folder.", "term": "Definition", "wide": true }, { "description": "teardown/test-database.teardown.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-teardown-tag", "title": "Teardown Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that abandons an operation that runs past its allowed time, filed in a timeouts folder.", "term": "Definition", "wide": true }, { "description": "timeouts/checkout-request.timeout.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "[Timeout](/records/lexicon/timeout)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timeout-tag", "title": "Timeout Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs work after a delay or at a fixed rate, filed in a timers folder.", "term": "Definition", "wide": true }, { "description": "timers/autosave.timer.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timer-tag", "title": "Timer Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that creates, parses or compares recorded instants in time, filed in a timestamps folder.", "term": "Definition", "wide": true }, { "description": "timestamps/audit-entry.timestamp.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timestamp-tag", "title": "Timestamp Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that converts times between zones and their offsets, filed in a timezones folder.", "term": "Definition", "wide": true }, { "description": "timezones/meeting.timezone.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-timezone-tag", "title": "Timezone Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that primes caches and connections so the first real request runs at normal speed, filed in a warmup folder.", "term": "Definition", "wide": true }, { "description": "warmup/price-cache.warmup.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-warmup-tag", "title": "Warmup Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that groups events into bounded spans of time for aggregation, filed in a windows folder.", "term": "Definition", "wide": true }, { "description": "windows/five-minute.window.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-window-tag", "title": "Window Tag" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Runtime Concerns](/records/lexicon-category/runtime-concerns)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the tag for a file that runs work on its own thread or process apart from the caller, filed in a workers folder.", "term": "Definition", "wide": true }, { "description": "workers/video-encode.worker.ts", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the naming gate, which refuses a filename whose last segment before the extension is an undeclared tag or differs from its folder's tag", "term": "Checked by" }, { "description": "Every filename whose concern slot holds the tag, and the folder holding each such file", "term": "Population" }, { "description": "A verdict stands until a file carrying the tag is created, moved or renamed, or the declared vocabulary changes", "term": "Freshness" }, { "description": "The lint run fails a file whose tag is undeclared or disagrees with its folder", "term": "Refusal" }, { "description": "Each filename parsed by position against the declared concern vocabulary", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite lints a file whose tag is undeclared and one whose tag differs from its folder, and passes a conforming file", "term": "Evidence" }, { "description": "The declared concern vocabulary, which a filename's tag and its folder conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-worker-tag", "title": "Worker Tag" } ], "title": "Runtime Concerns" }, { "icon": "bi-book", "id": "lexicon-category-runtime-discovery-dynamic-binding", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add new capabilities at runtime without modifying the core.", "term": "Definition", "wide": true }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capability-addition-without-core-modification", "title": "Capability Addition without Core Modification" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A core fixed at build time that cannot accept new capabilities without being recompiled.", "term": "Definition", "wide": true }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-closed-static-core", "title": "Closed Static Core" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Fixing at build time which implementation a call uses or how components are wired together, so neither can vary or be discovered at runtime.", "term": "Definition", "wide": true }, { "description": "Early Binding, Static Wiring, Static Linking", "term": "Aliases" }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Referenced by" }, { "description": "[Manual Registration](/records/lexicon/manual-registration): Compile-time binding fixes the choice in the build, while manual registration lists each component by hand at runtime.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compile-time-binding", "title": "Compile-Time Binding" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to postpone choosing a concrete implementation until runtime, so each environment can assemble its own.", "term": "Definition", "wide": true }, { "description": "Environment-Specific Composition", "term": "Aliases" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-implementation-choice", "title": "Deferred Implementation Choice" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking at startup that every discovered component declares the contract it claims.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Opaque Runtime Behavior](/records/architecture/opaque-runtime-behavior), [Manifest-Based Design](/records/architecture/manifest-based-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-discovery-validation", "title": "Discovery Validation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to route requests to service instances discovered at runtime.", "term": "Definition", "wide": true }, { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-routing", "title": "Dynamic Routing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which new behavior can be added with minimal change to existing code.", "term": "Definition", "wide": true }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extensibility", "title": "Extensibility" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Hardcoding service network addresses instead of discovering them dynamically.", "term": "Definition", "wide": true }, { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Service Discovery](/records/architecture/service-discovery)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-endpoints", "title": "Hardcoded Endpoints" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Requiring each component to be registered by hand instead of being discovered automatically.", "term": "Definition", "wide": true }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manual-registration", "title": "Manual Registration" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "Replacing a branching conditional on type with polymorphic dispatch through a shared interface.", "term": "Definition", "wide": true }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Polymorphism](/records/architecture/polymorphism)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replace-conditional-with-polymorphism", "title": "Replace Conditional with Polymorphism" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a symbol's concrete binding be resolved, by discovery or from configuration, during execution rather than at compile time.", "term": "Definition", "wide": true }, { "description": "Runtime Discovery or Configuration", "term": "Aliases" }, { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Binding](/records/architecture/dynamic-binding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-resolution", "title": "Runtime Resolution" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability for a component to register itself on load without external wiring.", "term": "Definition", "wide": true }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-self-registration", "title": "Self-Registration" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Runtime Discovery / Dynamic Binding](/records/lexicon-category/runtime-discovery-dynamic-binding)", "Layer: [Extensibility Core](/records/layer/extensibility-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which scanning for components at startup slows the system's initialization.", "term": "Definition", "wide": true }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with runtime-discovery", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-startup-cost", "title": "Startup Cost" } ], "title": "Runtime Discovery / Dynamic Binding" }, { "icon": "bi-book", "id": "lexicon-category-scalability-performance-optimization", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to shield a system from abusive or excessive request volume.", "term": "Definition", "wide": true }, { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-abuse-overload-protection", "title": "Abuse/Overload Protection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding an index on the fields a slow query filters or sorts by.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Latency](/records/architecture/latency), [Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Time Complexity](/records/architecture/time-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-add-index", "title": "Add Index" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which every read returns the most recent write, which caching trades away for speed.", "term": "Definition", "wide": true }, { "description": "[Caching](/records/architecture/caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with caching", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-always-fresh-reads", "title": "Always-Fresh Reads" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Asserting performance characteristics from anecdote or intuition rather than measured evidence.", "term": "Definition", "wide": true }, { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big O Notation](/records/architecture/big-o-notation), [Benchmarking](/records/architecture/benchmarking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anecdotal-performance-claims", "title": "Anecdotal Performance Claims" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Judging how fast code runs from casual observation instead of controlled measurement.", "term": "Definition", "wide": true }, { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anecdotal-timing", "title": "Anecdotal Timing" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The measured rates at which requests arrive and at which a server completes them, the inputs a queuing model needs.", "term": "Definition", "wide": true }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-arrival-and-service-rates", "title": "Arrival and Service Rates" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for loading the related data for many items in one query or call instead of one per item.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chatty Interface](/records/architecture/chatty-interface), [N Plus One Query](/records/architecture/n-plus-one-query)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-batch-fetch", "title": "Batch Fetch" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to recognize which component limits a system's overall throughput.", "term": "Definition", "wide": true }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Scalability](/records/architecture/scalability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bottleneck-awareness", "title": "Bottleneck Awareness" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to locate the component that most constrains overall performance.", "term": "Definition", "wide": true }, { "description": "[Profiling](/records/architecture/profiling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bottleneck-detection", "title": "Bottleneck Detection" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Measured data identifying which component constrains performance, justifying where to optimize.", "term": "Definition", "wide": true }, { "description": "[Optimization](/records/architecture/optimization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Optimization](/records/architecture/optimization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bottleneck-evidence", "title": "Bottleneck Evidence" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A single stage that constrains overall throughput because all work must pass through it.", "term": "Definition", "wide": true }, { "description": "[Throughput](/records/architecture/throughput)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Scalability](/records/architecture/scalability), [Throughput](/records/architecture/throughput)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bottlenecks", "title": "Bottlenecks" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring what a cache entry is keyed by, how long it lives and what invalidates it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cache-contract", "title": "Cache Contract" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of removing or refreshing cached entries so stale data is not served.", "term": "Definition", "wide": true }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with cdn-edge-caching", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cache-invalidation", "title": "Cache Invalidation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing or refreshing cached entries in the same change that writes the data behind them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design), [Read-Your-Writes Violation](/records/architecture/read-your-writes-violation), [Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cache-invalidation-on-write", "title": "Cache Invalidation on Write" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that content be stable enough to serve from a cache without harmful staleness.", "term": "Definition", "wide": true }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cacheable-content", "title": "Cacheable Content" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to raise capacity by enlarging a single machine rather than adding more machines.", "term": "Definition", "wide": true }, { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capacity-increase-without-distribution", "title": "Capacity Increase without Distribution" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of how a system's capacity responds to load, used to predict its limits.", "term": "Definition", "wide": true }, { "description": "[Throughput](/records/architecture/throughput)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Throughput](/records/architecture/throughput)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-capacity-model", "title": "Capacity Model" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for processing large data in fixed-size pieces, so memory use stays bounded.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space Complexity](/records/architecture/space-complexity), [Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-chunked-processing", "title": "Chunked Processing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to compare algorithms by how their cost grows, independent of hardware.", "term": "Definition", "wide": true }, { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-comparative-analysis", "title": "Comparative Analysis" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reason about how an algorithm's cost grows with input size.", "term": "Definition", "wide": true }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complexity-awareness", "title": "Complexity Awareness" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of how an algorithm's resource use scales with input size.", "term": "Definition", "wide": true }, { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complexity-model", "title": "Complexity Model" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which constant factors, ignored by asymptotic analysis, affect measured performance.", "term": "Definition", "wide": true }, { "description": "[Big O Notation](/records/architecture/big-o-notation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with big-o-notation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-constant-factor-practicality", "title": "Constant-Factor Practicality" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for including tenant, identity, version and every input that changes the result in a cache key.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design), [Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-keyed-cache", "title": "Context-Keyed Cache" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system delivers its work at the lowest resource cost.", "term": "Definition", "wide": true }, { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-efficiency", "title": "Cost Efficiency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a bigger single machine costs disproportionately more and eventually hits a hard limit.", "term": "Definition", "wide": true }, { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with vertical-scaling", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-limit", "title": "Cost/Limit" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of processor time a technique consumes, often traded against memory savings.", "term": "Definition", "wide": true }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with memory-efficiency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cpu-cost", "title": "CPU Cost" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of difficulty and cost of a query that must gather data from multiple shards.", "term": "Definition", "wide": true }, { "description": "[Sharding](/records/architecture/sharding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with sharding", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-shard-queries", "title": "Cross-Shard Queries" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of intricacy introduced by spreading work across distributed nodes.", "term": "Definition", "wide": true }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with bottleneck-analysis", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-complexity", "title": "Distributed Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of coordination overhead required to keep distributed instances consistent.", "term": "Definition", "wide": true }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with horizontal-scaling", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-coordination", "title": "Distributed Coordination" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add or remove capacity automatically as demand rises and falls.", "term": "Definition", "wide": true }, { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-capacity", "title": "Dynamic Capacity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to complete work using the fewest operations and least resource for the input.", "term": "Definition", "wide": true }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-efficient-processing", "title": "Efficient Processing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a test or runtime environment diverges from a reference over time, undermining comparability.", "term": "Definition", "wide": true }, { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with benchmarking", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-environment-drift", "title": "Environment Drift" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving per-user or per-request state out of instance memory into a shared store.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Elasticity](/records/architecture/elasticity), [Load Balancing](/records/architecture/load-balancing), [Statelessness](/records/architecture/statelessness), [Stateless Processing](/records/architecture/stateless-processing), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-externalize-session-state", "title": "Externalize Session State" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that session or request state be held outside the serving instance, in a shared store.", "term": "Definition", "wide": true }, { "description": "[Statelessness](/records/architecture/statelessness)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Statelessness](/records/architecture/statelessness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-externalized-state", "title": "Externalized State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Allocating a static amount of capacity regardless of demand, so the system is either starved or wasteful.", "term": "Definition", "wide": true }, { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fixed-provisioning", "title": "Fixed Provisioning" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Building a system around a fixed capacity ceiling that cannot grow when load increases.", "term": "Definition", "wide": true }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Scalability](/records/architecture/scalability), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fixed-capacity-design", "title": "Fixed-Capacity Design" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Loading an entire dataset into memory at once when streaming or chunking would suffice, risking exhaustion.", "term": "Definition", "wide": true }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Memory Efficiency](/records/architecture/memory-efficiency), [Streaming Architecture](/records/architecture/streaming-architecture), [Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-full-materialization", "title": "Full Materialization" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to serve content from a location near the user, cutting distance latency.", "term": "Definition", "wide": true }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-geographically-local-delivery", "title": "Geographically-Local Delivery" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A single mutable state shared across all workers, forcing coordination and preventing independent scaling.", "term": "Definition", "wide": true }, { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-shared-state", "title": "Global Shared State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to absorb increasing load without redesign.", "term": "Definition", "wide": true }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Scalability](/records/architecture/scalability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-growth-handling", "title": "Growth Handling" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Sizing capacity from guesswork rather than a model of arrival and service rates.", "term": "Definition", "wide": true }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guess-based-capacity", "title": "Guess-Based Capacity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Optimizing based on assumptions about where time is spent rather than profiling evidence.", "term": "Definition", "wide": true }, { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Performance Engineering](/records/architecture/performance-engineering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guess-based-optimization", "title": "Guess-Based Optimization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Deciding where to optimize by intuition instead of measured profiling data.", "term": "Definition", "wide": true }, { "description": "[Profiling](/records/architecture/profiling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-guesswork", "title": "Guesswork" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A fixed upper bound on a single machine's resources that caps how far vertical scaling can go.", "term": "Definition", "wide": true }, { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hard-resource-ceiling", "title": "Hard Resource Ceiling" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which code stays simple and clear, sometimes traded against maximal efficiency.", "term": "Definition", "wide": true }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with algorithmic-efficiency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implementation-simplicity", "title": "Implementation Simplicity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Selecting an algorithm whose complexity scales poorly for the expected input size.", "term": "Definition", "wide": true }, { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency)", "term": "Referenced by" }, { "description": "[N Plus One Query](/records/architecture/n-plus-one-query): An inefficient algorithm scales poorly in its own complexity, while an N plus one query issues one extra query per item fetched.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Time Complexity](/records/architecture/time-complexity), [Big O Notation](/records/architecture/big-o-notation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inefficient-algorithm-choice", "title": "Inefficient Algorithm Choice" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of the input dimension against which an algorithm's running time is measured.", "term": "Definition", "wide": true }, { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-input-size-model", "title": "Input Size Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Binding a client to a specific server instance for its state, preventing free rebalancing across instances.", "term": "Definition", "wide": true }, { "description": "[Statelessness](/records/architecture/statelessness)", "term": "Referenced by" }, { "description": "[Temporal Coupling](/records/architecture/temporal-coupling): Instance affinity ties a client to one server's state, while temporal coupling requires operations in an undocumented order.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Statelessness](/records/architecture/statelessness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-instance-affinity", "title": "Instance Affinity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Holding request-spanning state on one instance, so requests cannot be served by any other instance.", "term": "Definition", "wide": true }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling), [Statelessness](/records/architecture/statelessness)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-instance-local-state", "title": "Instance-Local State" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The rules determining when cached entries are considered stale and must be refreshed or evicted.", "term": "Definition", "wide": true }, { "description": "[Caching](/records/architecture/caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invalidation-policy", "title": "Invalidation Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to grow storage and throughput by spreading a dataset across many shards.", "term": "Definition", "wide": true }, { "description": "[Sharding](/records/architecture/sharding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sharding](/records/architecture/sharding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-large-dataset-scaling", "title": "Large Dataset Scaling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to lower response time by serving results from a nearer or faster source.", "term": "Definition", "wide": true }, { "description": "[Caching](/records/architecture/caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-reduction", "title": "Latency Reduction" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process a high volume of work without degrading.", "term": "Definition", "wide": true }, { "description": "[Throughput](/records/architecture/throughput)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Throughput](/records/architecture/throughput)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-load-handling", "title": "Load Handling" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of the expected volume and pattern of demand a system must handle.", "term": "Definition", "wide": true }, { "description": "[Scalability](/records/architecture/scalability)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Scalability](/records/architecture/scalability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-load-model", "title": "Load Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Tuning a non-bottleneck section for marginal gains while the constraint that limits performance goes unaddressed.", "term": "Definition", "wide": true }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-micro-optimization", "title": "Local Micro-Optimization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Performing lengthy synchronous work on a request path, blocking it and inflating latency.", "term": "Definition", "wide": true }, { "description": "[Latency](/records/architecture/latency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Latency](/records/architecture/latency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-long-blocking-work", "title": "Long Blocking Work" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of performance cost that the act of measuring imposes on the system being measured.", "term": "Definition", "wide": true }, { "description": "[Profiling](/records/architecture/profiling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with profiling", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-measurement-overhead", "title": "Measurement Overhead" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A representation of how an algorithm's memory use grows with input size.", "term": "Definition", "wide": true }, { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-memory-model", "title": "Memory Model" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to handle larger inputs without memory use growing prohibitively.", "term": "Definition", "wide": true }, { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-memory-scalability", "title": "Memory Scalability" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The simplifying premises a performance model depends on, which limit how well it matches reality.", "term": "Definition", "wide": true }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with queuing-theory", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-model-assumptions", "title": "Model Assumptions" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to use multiple processor cores simultaneously for a single workload.", "term": "Definition", "wide": true }, { "description": "[Parallelism](/records/architecture/parallelism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parallelism](/records/architecture/parallelism)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multi-core-utilization", "title": "Multi-Core Utilization" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The precondition that more than one interchangeable backend exists across which traffic can be spread.", "term": "Definition", "wide": true }, { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multiple-targets", "title": "Multiple Targets" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to relieve the origin server by serving cached copies from the edge.", "term": "Definition", "wide": true }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" }, { "description": "[Geographically-Local Delivery](/records/lexicon/geographically-local-delivery): Origin offload relieves the origin server, while local delivery cuts the distance to the user.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-origin-offload", "title": "Origin Offload" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Serving all content directly from the origin with no edge caching, concentrating load and adding distance latency.", "term": "Definition", "wide": true }, { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CDN / Edge Caching](/records/architecture/cdn-edge-caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-origin-only-serving", "title": "Origin-Only Serving" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which allocated capacity exceeds demand, trading waste for safety margin.", "term": "Definition", "wide": true }, { "description": "[Resource Utilization](/records/architecture/resource-utilization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with resource-utilization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-over-provisioning", "title": "Over-Provisioning" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to make progress on multiple tasks over the same period by interleaving them.", "term": "Definition", "wide": true }, { "description": "[Concurrency](/records/architecture/concurrency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concurrency](/records/architecture/concurrency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-overlapping-work", "title": "Overlapping Work" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The field whose value determines which shard or partition a record belongs to.", "term": "Definition", "wide": true }, { "description": "[Sharding](/records/architecture/sharding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sharding](/records/architecture/sharding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partition-key", "title": "Partition Key" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A scheme for dividing data or work across independent partitions to distribute load and enable parallelism.", "term": "Definition", "wide": true }, { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partition-strategy", "title": "Partition Strategy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Optimizing code before evidence shows it matters, adding complexity for gains that may never be needed.", "term": "Definition", "wide": true }, { "description": "[Optimization](/records/architecture/optimization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Optimization](/records/architecture/optimization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-premature-optimization", "title": "Premature Optimization" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The declared limits on how many requests a caller may make within a time window.", "term": "Definition", "wide": true }, { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-quota-policy", "title": "Quota Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to divert read queries to replicas, relieving the primary.", "term": "Definition", "wide": true }, { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-traffic-offload", "title": "Read Traffic Offload" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a client is guaranteed to see its own prior writes, which replica lag can break.", "term": "Definition", "wide": true }, { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with read-replica", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-your-writes-consistency", "title": "Read-Your-Writes Consistency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which code stays readable and maintainable, sometimes sacrificed for performance.", "term": "Definition", "wide": true }, { "description": "[Optimization](/records/architecture/optimization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with optimization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-readability-maintainability", "title": "Readability/Maintainability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of difficulty of redistributing data when partitions are added or removed.", "term": "Definition", "wide": true }, { "description": "[Partitioning](/records/architecture/partitioning)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with partitioning", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rebalancing-complexity", "title": "Rebalancing Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to lessen work reaching a backend by serving repeat results from a cache.", "term": "Definition", "wide": true }, { "description": "[Caching](/records/architecture/caching)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-load", "title": "Reduced Load" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to catch a performance regression by comparing measurements against a baseline.", "term": "Definition", "wide": true }, { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-regression-detection", "title": "Regression Detection" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A controlled, reproducible environment in which measurements can be compared meaningfully across runs.", "term": "Definition", "wide": true }, { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Benchmarking](/records/architecture/benchmarking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repeatable-test-environment", "title": "Repeatable Test Environment" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a costly computation or query whose result does not change is repeated on every request.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Caching](/records/architecture/caching)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repeated-stable-computation", "title": "Repeated Stable Computation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for swapping an algorithm or data structure for one with better complexity for the inputs at hand.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Algorithmic Efficiency](/records/architecture/algorithmic-efficiency), [Time Complexity](/records/architecture/time-complexity), [Big O Notation](/records/architecture/big-o-notation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replace-algorithm", "title": "Replace Algorithm" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A workload that reflects production usage closely enough that measurements generalize.", "term": "Definition", "wide": true }, { "description": "[Profiling](/records/architecture/profiling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Profiling](/records/architecture/profiling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-representative-workload", "title": "Representative Workload" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of spare capacity remaining on a machine before its resource ceiling is reached.", "term": "Definition", "wide": true }, { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Vertical Scaling](/records/architecture/vertical-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-headroom", "title": "Resource Headroom" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Running resources far below or far above healthy utilization, either wasting capacity or saturating it.", "term": "Definition", "wide": true }, { "description": "[Resource Utilization](/records/architecture/resource-utilization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Resource Utilization](/records/architecture/resource-utilization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-waste-saturation", "title": "Resource Waste/Saturation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system reacts quickly to user actions or requests.", "term": "Definition", "wide": true }, { "description": "[Latency](/records/architecture/latency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Latency](/records/architecture/latency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-responsiveness", "title": "Responsiveness" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of assessing how a system's cost grows as load or input increases.", "term": "Definition", "wide": true }, { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scalability-analysis", "title": "Scalability Analysis" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add capacity by adding more machines that share the load.", "term": "Definition", "wide": true }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scale-out", "title": "Scale-Out" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A portion of work that must run serially, capping the speedup that parallelism can achieve.", "term": "Definition", "wide": true }, { "description": "[Parallelism](/records/architecture/parallelism)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parallelism](/records/architecture/parallelism), [Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sequential-bottleneck", "title": "Sequential Bottleneck" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Routing all of a client's requests to the same server instance so its session state stays local.", "term": "Definition", "wide": true }, { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with load-balancing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-session-affinity", "title": "Session Affinity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Concentrating all data in one store that cannot be partitioned, capping write and storage scalability.", "term": "Definition", "wide": true }, { "description": "[Sharding](/records/architecture/sharding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sharding](/records/architecture/sharding), [Partitioning](/records/architecture/partitioning)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-monolithic-store", "title": "Single Monolithic Store" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Directing all traffic to one target instead of distributing it, wasting capacity and creating a bottleneck.", "term": "Definition", "wide": true }, { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-target-routing", "title": "Single Target Routing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Serving all reads from the single primary, so read load contends with writes and limits throughput.", "term": "Definition", "wide": true }, { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Read Replica](/records/architecture/read-replica)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-primary-read-contention", "title": "Single-Primary Read Contention" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reason about how an algorithm's memory use grows with input size.", "term": "Definition", "wide": true }, { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-space-complexity-awareness", "title": "Space Complexity Awareness" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of added latency incurred when state is fetched from an external store rather than held locally.", "term": "Definition", "wide": true }, { "description": "[Statelessness](/records/architecture/statelessness)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with statelessness", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-access-latency", "title": "State Access Latency" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "A decision to make instances stateless or externalize state to a shared store, so any instance can serve any request.", "term": "Definition", "wide": true }, { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Horizontal Scaling](/records/architecture/horizontal-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-statelessness-or-shared-state-strategy", "title": "Statelessness or Shared State Strategy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to direct optimization effort at the specific constraint that limits performance.", "term": "Definition", "wide": true }, { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bottleneck Analysis](/records/architecture/bottleneck-analysis)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-targeted-improvement", "title": "Targeted Improvement" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which batching work raises throughput at the cost of per-item latency.", "term": "Definition", "wide": true }, { "description": "[Latency](/records/architecture/latency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with latency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-throughput-batching", "title": "Throughput/Batching" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to spread incoming requests across multiple backends evenly.", "term": "Definition", "wide": true }, { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Load Balancing](/records/architecture/load-balancing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-traffic-distribution", "title": "Traffic Distribution" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Permitting callers to make unlimited requests with no rate limit, allowing overload and abuse.", "term": "Definition", "wide": true }, { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rate Limiting](/records/architecture/rate-limiting)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-access", "title": "Unbounded Access" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "Accumulating state without bound so memory usage grows until the process exhausts it.", "term": "Definition", "wide": true }, { "description": "[Space Complexity](/records/architecture/space-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Space Complexity](/records/architecture/space-complexity), [Memory Efficiency](/records/architecture/memory-efficiency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-memory-growth", "title": "Unbounded Memory Growth" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "An algorithm whose running time grows without bound as input scales, becoming infeasible at size.", "term": "Definition", "wide": true }, { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Time Complexity](/records/architecture/time-complexity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-runtime-growth", "title": "Unbounded Runtime Growth" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to size capacity from measured utilization and wait-time targets.", "term": "Definition", "wide": true }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-utilization-based-sizing", "title": "Utilization-Based Sizing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to predict how long work will wait given arrival and service rates.", "term": "Definition", "wide": true }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Referenced by" }, { "description": "[Utilization-Based Sizing](/records/lexicon/utilization-based-sizing): Wait-time prediction forecasts how long work waits, while utilization-based sizing chooses capacity from measured load and a wait-time target.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-wait-time-prediction", "title": "Wait-Time Prediction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Scalability / Performance / Optimization](/records/lexicon-category/scalability-performance-optimization)", "Layer: [Performance Core](/records/layer/performance-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of delay before newly-added capacity becomes ready to serve traffic.", "term": "Definition", "wide": true }, { "description": "[Elasticity](/records/architecture/elasticity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with elasticity", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-warm-up-latency", "title": "Warm-Up Latency" } ], "title": "Scalability / Performance / Optimization" }, { "icon": "bi-book", "id": "lexicon-category-schema-canonical-data-semantics", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "An interface whose names and parameters hide what it does, so callers must guess or read the implementation.", "term": "Definition", "wide": true }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" }, { "description": "[Boolean Trap](/records/architecture/boolean-trap): An ambiguous API hides what an interface does by any means, while a boolean trap is the case of boolean parameters hiding intent at the call site.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Uniform Interface](/records/architecture/uniform-interface), [Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ambiguous-api", "title": "Ambiguous API" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Representing the same value in multiple encodings without normalizing, so equal values compare as different.", "term": "Definition", "wide": true }, { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ambiguous-encoding", "title": "Ambiguous Encoding" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for serializing messages in a compact binary format whose schema the reader and writer share.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Contract](/records/architecture/schema-contract)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-binary-schema-encoding", "title": "Binary Schema Encoding" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing one canonical model limits each bounded context's freedom to model its own domain.", "term": "Definition", "wide": true }, { "description": "[Canonical Model](/records/architecture/canonical-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canonical-model", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-context-autonomy", "title": "Bounded Context Autonomy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which sharing one enterprise data model erodes the conceptual purity of each bounded context.", "term": "Definition", "wide": true }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" }, { "description": "[Local Model Autonomy](/records/lexicon/local-model-autonomy): Bounded context purity is each context's concepts staying clean, while local model autonomy is each context being free to evolve its own model.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canonical-data-model", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-context-purity", "title": "Bounded Context Purity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each fact have one authoritative definition that all consumers reference.", "term": "Definition", "wide": true }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-canonical-definition", "title": "Canonical Definition" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a single normalized form be defined for values before they are compared or stored.", "term": "Definition", "wide": true }, { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-canonical-format", "title": "Canonical Format" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an interface's names convey what each operation does and expects.", "term": "Definition", "wide": true }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-clear-semantics", "title": "Clear Semantics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which clever, non-obvious abstractions trade familiarity for surprise to the reader.", "term": "Definition", "wide": true }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with principle-of-least-surprise", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-clever-abstractions", "title": "Clever Abstractions" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which naming an interface fully for clarity works against keeping names short.", "term": "Definition", "wide": true }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with intent-revealing-interface, [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concise-naming", "title": "Concise Naming" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a design follow shared naming, placement and behavior conventions, so its parts can be found automatically and behave as expected.", "term": "Definition", "wide": true }, { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Discovery](/records/architecture/runtime-discovery), [Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-convention", "title": "Convention" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability of callers to use an interface correctly because its names reveal its intent.", "term": "Definition", "wide": true }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-correct-usage", "title": "Correct Usage" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which agreeing on shared terms strains against the distinct vocabularies different contexts need.", "term": "Definition", "wide": true }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with ubiquitous-language", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-context-terminology", "title": "Cross-Context Terminology" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to map data between systems through a single shared canonical representation.", "term": "Definition", "wide": true }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cross-system-mapping", "title": "Cross-System Mapping" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the meaning and dependencies of data be understood before it is decomposed into relations.", "term": "Definition", "wide": true }, { "description": "[Normalization](/records/architecture/normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Normalization](/records/architecture/normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-semantics", "title": "Data Semantics" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to recognize and collapse values that are equivalent once reduced to canonical form.", "term": "Definition", "wide": true }, { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deduplication", "title": "Deduplication" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for choosing one representation for a missing value and stating what it means at the boundary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-define-absence-semantics", "title": "Define Absence Semantics" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A read-optimized model that deliberately duplicates data to serve queries fast, trading storage and write cost for read speed.", "term": "Definition", "wide": true }, { "description": "[Normalization](/records/architecture/normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with normalization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-denormalized-read-models", "title": "Denormalized Read Models" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to give each concept one unambiguous name and meaning across a domain.", "term": "Definition", "wide": true }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-disambiguation", "title": "Disambiguation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that domain experts and developers collaborate to agree on shared terminology.", "term": "Definition", "wide": true }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-collaboration", "title": "Domain Collaboration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Two or more places each claiming to own the same fact, so they drift and disagree over time.", "term": "Definition", "wide": true }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" }, { "description": "[Claimed Foreign Tree](/records/lexicon/claimed-foreign-tree): Duplicated authority is two owners for one fact, while a claimed foreign tree is governing names another runtime owns.", "term": "Distinct from" }, { "description": "[Depth-Relief Container](/records/lexicon/depth-relief-container): Duplicated authority is two owners for one fact, while a depth-relief container is a container declared to shorten a path.", "term": "Distinct from" }, { "description": "[Magic Value](/records/architecture/magic-value): Duplicated authority is two owning copies of a fact, while a magic value is a fact written as an unexplained literal, however many times.", "term": "Distinct from" }, { "description": "[Ignore-List Silencing](/records/lexicon/ignore-list-silencing): Duplicated authority is two owners for one fact, while ignore-list silencing removes a file from the taxonomy to hide a finding.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth), [Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicated-authority", "title": "Duplicated Authority" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The same fact copied into many columns and rows, so updates must touch every copy or leave them inconsistent.", "term": "Definition", "wide": true }, { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Normalization](/records/architecture/normalization), [Database Normalization](/records/architecture/database-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-duplicated-denormalized-columns", "title": "Duplicated Denormalized Columns" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Passing untyped values across module or service boundaries, so type errors surface only at runtime.", "term": "Definition", "wide": true }, { "description": "[Type Safety](/records/architecture/type-safety)", "term": "Referenced by" }, { "description": "[Stringly Typed Programming](/records/architecture/stringly-typed-programming): Untyped boundaries pass untyped values between modules, while stringly typed programming encodes states and types as strings anywhere in the code.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Type Safety](/records/architecture/type-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-untyped-boundaries", "title": "Dynamic Untyped Boundaries" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that values crossing a boundary carry explicit, declared types rather than open-ended ones.", "term": "Definition", "wide": true }, { "description": "[Type Safety](/records/architecture/type-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Type Safety](/records/architecture/type-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-explicit-types", "title": "Explicit Types" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which strictly validating every payload rejects the loosely-shaped input a caller might legitimately send.", "term": "Definition", "wide": true }, { "description": "[Schema Validation](/records/architecture/schema-validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with schema-validation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flexible-input", "title": "Flexible Input" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the dependencies determining which attributes fix others be identified before decomposing a schema.", "term": "Definition", "wide": true }, { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-functional-dependencies", "title": "Functional Dependencies" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for modeling a value that takes one of several shapes as a union whose variants carry a tag the type checker reads.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stringly Typed Programming](/records/architecture/stringly-typed-programming), [Self-Describing Structures](/records/architecture/self-describing-structures)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-discriminated-union", "title": "Introduce Discriminated Union" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a bounded context is free to define and evolve its own data model independently of a shared canonical one.", "term": "Definition", "wide": true }, { "description": "[Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canonical-data-model", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-local-model-autonomy", "title": "Local Model Autonomy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which reducing values to a canonical form can discard distinctions the original preserved.", "term": "Definition", "wide": true }, { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canonicalization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lossless-preservation", "title": "Lossless Preservation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Several inconsistent models of the same concept coexisting, so translations between them drift and conflict.", "term": "Definition", "wide": true }, { "description": "[Canonical Model](/records/architecture/canonical-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonical Model](/records/architecture/canonical-model), [Canonical Data Model](/records/architecture/canonical-data-model)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multiple-competing-models", "title": "Multiple Competing Models" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that names for the same concept be used consistently across an interface.", "term": "Definition", "wide": true }, { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Referenced by" }, { "description": "[Set-Relative Member Name](/records/architecture/set-relative-member-name): Naming consistency is one name per concept across an interface, while a set-relative member name leaves out what its folder already says.", "term": "Distinct from" }, { "description": "[Clear Semantics](/records/lexicon/clear-semantics): Naming consistency is the same concept always getting the same name, while clear semantics is each name saying what the operation does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Intent-Revealing Interface](/records/architecture/intent-revealing-interface), [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-naming-consistency", "title": "Naming Consistency" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing a broad type with one that admits only the values the domain allows.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Primitive Obsession](/records/architecture/primitive-obsession), [Registry Pattern](/records/architecture/registry-pattern), [Type Safety](/records/architecture/type-safety)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-narrow-type", "title": "Narrow Type" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to store each fact once, so it cannot drift out of sync with copies and no update anomaly can arise.", "term": "Definition", "wide": true }, { "description": "Update-Anomaly Elimination", "term": "Aliases" }, { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-non-redundant-storage", "title": "Non-Redundant Storage" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to translate between systems through one shared canonical form rather than many pairwise mappings.", "term": "Definition", "wide": true }, { "description": "[Canonical Model](/records/architecture/canonical-model)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonical Model](/records/architecture/canonical-model)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-normalized-translation", "title": "Normalized Translation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which one term legitimately carries different meanings in different bounded contexts.", "term": "Definition", "wide": true }, { "description": "[Semantic Consistency](/records/architecture/semantic-consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with semantic-consistency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-polysemy-across-contexts", "title": "Polysemy Across Contexts" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which splitting data across normalized relations forces costly joins on read.", "term": "Definition", "wide": true }, { "description": "[Normalization](/records/architecture/normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with normalization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-query-performance", "title": "Query Performance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which requiring explicit types slows the quick, exploratory coding that dynamic typing allows.", "term": "Definition", "wide": true }, { "description": "[Type Safety](/records/architecture/type-safety)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with type-safety", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rapid-scripting", "title": "Rapid Scripting" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which normalizing a schema into many relations forces joins that slow reads.", "term": "Definition", "wide": true }, { "description": "[Database Normalization](/records/architecture/database-normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with database-normalization", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-performance", "title": "Read Performance" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to eliminate duplicated facts by referencing a single stored copy.", "term": "Definition", "wide": true }, { "description": "[Normalization](/records/architecture/normalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Normalization](/records/architecture/normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-redundancy", "title": "Reduced Redundancy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to use an interface safely because it behaves the way its name and shape suggest.", "term": "Definition", "wide": true }, { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Principle of Least Surprise](/records/architecture/principle-of-least-surprise)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-use", "title": "Safe Use" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for storing every published schema and its versions in one registry that producers and consumers check against.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Drift](/records/architecture/schema-drift)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-schema-registry", "title": "Schema Registry" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to apply security checks reliably by first reducing input to one unambiguous form.", "term": "Definition", "wide": true }, { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canonicalization](/records/architecture/canonicalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-security-checks", "title": "Security Checks" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a shared canonical schema competes with each service's need for its own tailored schema.", "term": "Definition", "wide": true }, { "description": "[Canonical Schema](/records/architecture/canonical-schema)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canonical-schema", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-service-specific-schemas", "title": "Service-Specific Schemas" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Naming code in technical terms disconnected from the domain, so experts and developers talk past each other.", "term": "Definition", "wide": true }, { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Ubiquitous Language](/records/architecture/ubiquitous-language)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-technical-domain-mismatch", "title": "Technical/Domain Mismatch" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Schema / Canonical Data / Semantics](/records/lexicon-category/schema-canonical-data-semantics)", "Layer: [Contracts Core](/records/layer/contracts-core)" ], "kind": "list" }, { "entries": [ { "description": "Accepting data at a boundary with no schema, so malformed or unexpected shapes flow in unchecked.", "term": "Definition", "wide": true }, { "description": "[Schema Validation](/records/architecture/schema-validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Explicit Contracts](/records/architecture/explicit-contracts), [Data Contract](/records/architecture/data-contract), [Schema Validation](/records/architecture/schema-validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-untyped-payloads", "title": "Untyped Payloads" } ], "title": "Schema / Canonical Data / Semantics" }, { "icon": "bi-book", "id": "lexicon-category-security-privacy-compliance", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Authorization logic scattered inline throughout the codebase instead of centralized, leaving checks inconsistent and easy to omit.", "term": "Definition", "wide": true }, { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-permission-checks", "title": "Ad-Hoc Permission Checks" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Treating any request that carries ambient credentials, such as a session cookie, as legitimate without verifying its origin or intent.", "term": "Definition", "wide": true }, { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ambient-credential-trust", "title": "Ambient-Credential Trust" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to analyze collected data and tailor experiences to individuals, in tension with strict data minimization.", "term": "Definition", "wide": true }, { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with privacy-by-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-analytics-personalization", "title": "Analytics/Personalization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Permitting access to sensitive resources without first establishing the caller's identity.", "term": "Definition", "wide": true }, { "description": "[Authentication](/records/architecture/authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authentication](/records/architecture/authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-anonymous-sensitive-access", "title": "Anonymous Sensitive Access" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The data, systems, and capabilities of value that a threat model enumerates as the things worth protecting.", "term": "Definition", "wide": true }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" }, { "description": "[Threat Scenarios](/records/lexicon/threat-scenarios): Assets are the things worth protecting, while threat scenarios are the ways an attacker might reach them.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assets", "title": "Assets" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Designing defenses around assumed threats rather than a deliberate analysis of realistic attack vectors.", "term": "Definition", "wide": true }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" }, { "description": "[Security Theater](/records/architecture/security-theater): Assumption-driven security defends against threats nobody analyzed, while security theater shows controls that do not reduce the real threat.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-assumption-driven-security", "title": "Assumption-Driven Security" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Declared descriptions of the subject, resource, action, and environment attributes that an access policy evaluates.", "term": "Definition", "wide": true }, { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-attribute-definitions", "title": "Attribute Definitions" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The verified identity of the user or service on whose behalf a request executes, against which permissions are checked.", "term": "Definition", "wide": true }, { "description": "[Authorization](/records/architecture/authorization)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authorization](/records/architecture/authorization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-authenticated-principal", "title": "Authenticated Principal" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Conflating authentication with authorization, so any authenticated caller is granted access without a permission check.", "term": "Definition", "wide": true }, { "description": "[Authorization](/records/architecture/authorization)", "term": "Referenced by" }, { "description": "[Authorization Scattering](/records/architecture/authorization-scattering): Authenticated-equals-authorized skips the permission check, while authorization scattering spreads the checks with no central policy.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authorization](/records/architecture/authorization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-authenticated-equals-authorized", "title": "Authenticated-Equals-Authorized" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The declared set of rules determining which principals may perform which actions on which resources.", "term": "Definition", "wide": true }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Access Control](/records/architecture/access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-authorization-policy", "title": "Authorization Policy" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for testing each protected operation with permitted and refused identities.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authorization Scattering](/records/architecture/authorization-scattering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-authorization-tests", "title": "Authorization Tests" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to enforce rules automatically at runtime without manual intervention.", "term": "Definition", "wide": true }, { "description": "[Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-control", "title": "Automated Control" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a session's validity is time-limited so that access does not persist indefinitely.", "term": "Definition", "wide": true }, { "description": "[Session Management](/records/architecture/session-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Session Management](/records/architecture/session-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-session-lifetime", "title": "Bounded Session Lifetime" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Granting sweeping administrative privileges by default instead of the least access each role requires.", "term": "Definition", "wide": true }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-broad-admin-access", "title": "Broad Admin Access" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for evaluating every authorization decision through one policy model instead of scattered checks.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authorization Scattering](/records/architecture/authorization-scattering), [Authorization](/records/architecture/authorization), [Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-centralize-policy", "title": "Centralize Policy" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of issuing, deploying, renewing, and revoking the digital certificates that transport encryption depends on.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with encryption-in-transit", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-certificate-management", "title": "Certificate Management" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of additional effort a protective measure imposes on client implementations.", "term": "Definition", "wide": true }, { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with csrf-protection", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-client-complexity", "title": "Client Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to manage access by assigning broad, role-level permission sets rather than per-individual grants.", "term": "Definition", "wide": true }, { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coarse-grained-permission-management", "title": "Coarse-Grained Permission Management" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep a breach confined to one layer or segment so it cannot spread system-wide.", "term": "Definition", "wide": true }, { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compromise-containment", "title": "Compromise Containment" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which data is kept secret from all but authorized parties.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" }, { "description": "[Integrity](/records/lexicon/integrity): Confidentiality keeps data from being read, while integrity keeps it from being altered.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-confidentiality", "title": "Confidentiality" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which data held at rest remains unreadable to anyone without authorized access.", "term": "Definition", "wide": true }, { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-confidentiality-of-stored-data", "title": "Confidentiality of Stored Data" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The recorded permission and governing rules under which personal data may lawfully be collected and processed.", "term": "Definition", "wide": true }, { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consent-policy", "title": "Consent/Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to base access decisions on the runtime context of a request, such as its attributes, its environment and the resource's state.", "term": "Definition", "wide": true }, { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-aware-authorization", "title": "Context-Aware Authorization" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-context-aware-encoding", "title": "Context-Aware Encoding" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of re-verifying a caller's authorization on every request rather than trusting a single earlier check.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuous-authorization", "title": "Continuous Authorization" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of choosing which security controls to apply based on identified threats and their priority.", "term": "Definition", "wide": true }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-control-selection", "title": "Control Selection" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The safeguards and countermeasures put in place to reduce security or compliance risk to an acceptable level.", "term": "Definition", "wide": true }, { "description": "[Compliance](/records/architecture/compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Defense in Depth](/records/architecture/defense-in-depth), [Compliance](/records/architecture/compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controls", "title": "Controls" }, { "blocks": [ { "items": [ "Kind: [principle](/records/kind/principle)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Collecting and retaining only the personal data strictly necessary for a stated purpose.", "term": "Definition", "wide": true }, { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-minimization", "title": "Data Minimization" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to safeguard data against unauthorized access, loss, or disclosure throughout its lifecycle.", "term": "Definition", "wide": true }, { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-protection", "title": "Data Protection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for refusing every access that no rule explicitly allows.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fail Secure](/records/architecture/fail-secure), [Secure by Default](/records/architecture/secure-by-default)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-default-deny", "title": "Default Deny" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "An explicit, declared set of rules specifying what is permitted or denied, against which enforcement acts.", "term": "Definition", "wide": true }, { "description": "[Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-defined-policy", "title": "Defined Policy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system is convenient and pleasant for developers to work with.", "term": "Definition", "wide": true }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with security-by-design", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-developer-ergonomics", "title": "Developer Ergonomics" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of freedom to vary a query's structure at runtime, constrained when inputs must be bound as parameters.", "term": "Definition", "wide": true }, { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with parameterized-queries", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dynamic-query-flexibility", "title": "Dynamic Query Flexibility" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system is easy to start using without upfront configuration.", "term": "Definition", "wide": true }, { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with secure-by-default", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ease-of-initial-use", "title": "Ease of Initial Use" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to generate and collect compliance evidence automatically from live systems rather than assembling it by hand.", "term": "Definition", "wide": true }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-evidence-automation", "title": "Evidence Automation" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which functionality is made accessible, which broadens capability but enlarges the attack surface.", "term": "Definition", "wide": true }, { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with attack-surface-reduction", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-exposure", "title": "Feature Exposure" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing or masking sensitive fields before data is logged, exported or displayed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-field-redaction", "title": "Field Redaction" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to grant or deny access at a precise level using specific attributes rather than broad roles.", "term": "Definition", "wide": true }, { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fine-grained-access-control", "title": "Fine-Grained Access Control" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect and reject requests that a user did not intentionally initiate.", "term": "Definition", "wide": true }, { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-forged-request-rejection", "title": "Forged-Request Rejection" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of latitude to present output in varied formats, constrained when encoding must be strict.", "term": "Definition", "wide": true }, { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with output-encoding", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-formatting-flexibility", "title": "Formatting Flexibility" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Embedding access rules directly in code, so changing policy requires a code change and cannot respond to runtime attributes.", "term": "Definition", "wide": true }, { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control), [Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-rules", "title": "Hardcoded Rules" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Embedding credentials, keys, or tokens directly in source or configuration, exposing them to anyone who can read it.", "term": "Definition", "wide": true }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" }, { "description": "[Secret Sprawl](/records/architecture/secret-sprawl): Hardcoded secrets are credentials embedded in source, while secret sprawl is credentials scattered across code, logs and configuration.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hardcoded-secrets", "title": "Hardcoded Secrets" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The evidence a principal presents to establish its identity, such as a password, token, or certificate.", "term": "Definition", "wide": true }, { "description": "[Authentication](/records/architecture/authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authentication](/records/architecture/authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-proof", "title": "Identity Proof" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to make access decisions grounded in a verified caller identity.", "term": "Definition", "wide": true }, { "description": "[Authentication](/records/architecture/authentication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authentication](/records/architecture/authentication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-aware-authorization", "title": "Identity-Aware Authorization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A session that never expires and is trusted from client-supplied state alone, so a captured token grants indefinite access.", "term": "Definition", "wide": true }, { "description": "[Session Management](/records/architecture/session-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Session Management](/records/architecture/session-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-immortal-client-trusted-session", "title": "Immortal Client-Trusted Session" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to stop untrusted input from being interpreted as executable code or commands.", "term": "Definition", "wide": true }, { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-injection-prevention", "title": "Injection Prevention" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to query data such that input can never be interpreted as part of the query structure.", "term": "Definition", "wide": true }, { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-injection-safe-data-access", "title": "Injection-Safe Data Access" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system accepts varied or loosely-structured input, in tension with strict validation.", "term": "Definition", "wide": true }, { "description": "[Input Validation](/records/architecture/input-validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with input-validation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-input-flexibility", "title": "Input Flexibility" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Shipping default settings that favor convenience over safety, leaving a system exposed unless it is explicitly hardened.", "term": "Definition", "wide": true }, { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-insecure-defaults", "title": "Insecure Defaults" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which data is protected from unauthorized or undetected alteration.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-integrity", "title": "Integrity" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of generating, distributing, rotating, and revoking cryptographic keys across their lifecycle.", "term": "Definition", "wide": true }, { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-key-management", "title": "Key Management" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of operational burden imposed by generating, rotating, and safeguarding cryptographic keys.", "term": "Definition", "wide": true }, { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with encryption-at-rest", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-key-operations", "title": "Key Operations" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of added latency and complexity introduced by verifying every request rather than trusting a perimeter.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with zero-trust-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-complexity", "title": "Latency/Complexity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that multiple independent safeguards protect a resource, so no single failure exposes it.", "term": "Definition", "wide": true }, { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layered-controls", "title": "Layered Controls" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for issuing each caller a credential that grants only the operations it performs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secret Sprawl](/records/architecture/secret-sprawl), [Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-least-privilege-credential", "title": "Least-Privilege Credential" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Security or compliance policies expressed in a structured, executable format that tools can evaluate directly.", "term": "Definition", "wide": true }, { "description": "[Policy as Code](/records/architecture/policy-as-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Policy as Code](/records/architecture/policy-as-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-machine-readable-policies", "title": "Machine-Readable Policies" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Relying solely on human review to catch policy violations, which neither scales nor reliably covers every case.", "term": "Definition", "wide": true }, { "description": "[Policy Enforcement](/records/architecture/policy-enforcement)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Policy Enforcement](/records/architecture/policy-enforcement), [Policy as Code](/records/architecture/policy-as-code)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manual-only-review", "title": "Manual-Only Review" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The condition of exposing only the endpoints, ports, and capabilities strictly required.", "term": "Definition", "wide": true }, { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-minimal-exposure", "title": "Minimal Exposure" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each principal hold only the permissions its function needs.", "term": "Definition", "wide": true }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-minimal-permissions", "title": "Minimal Permissions" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of reducing a risk's likelihood or impact through deliberate countermeasures.", "term": "Definition", "wide": true }, { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mitigation", "title": "Mitigation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a network into zones whose traffic between them passes declared controls.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-network-segmentation", "title": "Network Segmentation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to demonstrate continuously that controls remain effective, rather than only at audit time.", "term": "Definition", "wide": true }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ongoing-assurance", "title": "Ongoing Assurance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which broad access makes day-to-day operations easier, in tension with least privilege.", "term": "Definition", "wide": true }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with least-privilege", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-convenience", "title": "Operational Convenience" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for attacking a system under agreement to find the paths that bypass its controls.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Security Theater](/records/architecture/security-theater)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-penetration-testing", "title": "Penetration Testing" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A security model that trusts no network location implicitly and verifies every request regardless of origin.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-perimeterless-security", "title": "Perimeterless Security" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of intricacy added to a delivery pipeline by embedding continuous checks within it.", "term": "Definition", "wide": true }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with continuous-compliance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pipeline-complexity", "title": "Pipeline Complexity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Storing sensitive data unencrypted at rest, exposing it to anyone who reaches the underlying storage.", "term": "Definition", "wide": true }, { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption at Rest](/records/architecture/encryption-at-rest)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plaintext-sensitive-storage", "title": "Plaintext Sensitive Storage" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Sending data over an unencrypted channel, exposing it to interception and tampering in transit.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plaintext-transport", "title": "Plaintext Transport" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Verifying compliance only at isolated audit moments, leaving the intervals between checks unmonitored for drift.", "term": "Definition", "wide": true }, { "description": "[Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compliance](/records/architecture/compliance), [Continuous Compliance](/records/architecture/continuous-compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-point-in-time-audit-only", "title": "Point-in-Time Audit Only" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A runtime component that evaluates access requests against declared policies and returns permit or deny decisions.", "term": "Definition", "wide": true }, { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attribute-Based Access Control (ABAC)](/records/architecture/attribute-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-policy-engine", "title": "Policy Engine" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of keeping codified policies correct and current as requirements evolve.", "term": "Definition", "wide": true }, { "description": "[Policy as Code](/records/architecture/policy-as-code)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with policy-as-code", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-policy-maintenance", "title": "Policy Maintenance" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to apply controls in order of risk priority, addressing the greatest exposure first.", "term": "Definition", "wide": true }, { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-priority-based-controls", "title": "Priority-Based Controls" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system meets the privacy obligations imposed by law and policy.", "term": "Definition", "wide": true }, { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Privacy by Design](/records/architecture/privacy-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-privacy-compliance", "title": "Privacy Compliance" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reduce risk by designing safeguards in from the start rather than patching flaws later.", "term": "Definition", "wide": true }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-proactive-risk-reduction", "title": "Proactive Risk Reduction" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for tagging personal data with the purpose it was collected for and refusing uses outside it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing), [Privacy by Design](/records/architecture/privacy-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-purpose-binding", "title": "Purpose Binding" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Passing query values as bound parameters separate from the query text, so input can never alter the query structure.", "term": "Definition", "wide": true }, { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-query-parameter-binding", "title": "Query Parameter Binding" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Emitting untrusted data into output without encoding it for its context, enabling injection attacks such as cross-site scripting.", "term": "Definition", "wide": true }, { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-raw-output-rendering", "title": "Raw Output Rendering" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the impact of a compromise is confined to a limited scope.", "term": "Definition", "wide": true }, { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-blast-radius", "title": "Reduced Blast Radius" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which fewer exposed features leave a system harder to exploit.", "term": "Definition", "wide": true }, { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-exploitability", "title": "Reduced Exploitability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which safe defaults lower the chance of an insecure configuration.", "term": "Definition", "wide": true }, { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secure by Default](/records/architecture/secure-by-default)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-misconfiguration-risk", "title": "Reduced Misconfiguration Risk" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system conforms to the laws and regulations that govern it.", "term": "Definition", "wide": true }, { "description": "[Compliance](/records/architecture/compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compliance](/records/architecture/compliance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-regulatory-alignment", "title": "Regulatory Alignment" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deleting a credential from source and history and reading it from a secret store instead.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Hardcoded Configuration](/records/architecture/hardcoded-configuration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remove-secret-from-code", "title": "Remove Secret from Code" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for scanning source and history for credentials before a change is accepted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secret Sprawl](/records/architecture/secret-sprawl)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repository-secret-scan", "title": "Repository Secret Scan" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Confirming that a state-changing request originates from a trusted client, typically via a token or origin check.", "term": "Definition", "wide": true }, { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[CSRF Protection](/records/architecture/csrf-protection)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-request-origin-verification", "title": "Request Origin Verification" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to ensure that only permitted operations reach a protected resource.", "term": "Definition", "wide": true }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Access Control](/records/architecture/access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resource-protection", "title": "Resource Protection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring how long each class of data is kept and deleting it when the period ends.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Personal Data Oversharing](/records/architecture/personal-data-oversharing), [Privacy by Design](/records/architecture/privacy-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retention-policy", "title": "Retention Policy" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of examining a change or artifact against standards before it is accepted.", "term": "Definition", "wide": true }, { "description": "[Governance](/records/architecture/governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-review", "title": "Review" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to withdraw a principal's access immediately when a session or grant is terminated.", "term": "Definition", "wide": true }, { "description": "[Session Management](/records/architecture/session-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Session Management](/records/architecture/session-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-revocable-access", "title": "Revocable Access" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of discovering and cataloguing the risks that could affect a system or objective.", "term": "Definition", "wide": true }, { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Referenced by" }, { "description": "[Mitigation](/records/lexicon/mitigation): Risk identification finds the risks, while mitigation reduces them.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-risk-identification", "title": "Risk Identification" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Declared sets of permissions grouped into named roles that are assigned to principals.", "term": "Definition", "wide": true }, { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-role-definitions", "title": "Role Definitions" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which roles proliferate into many narrow definitions as access requirements grow.", "term": "Definition", "wide": true }, { "description": "[Role-Based Access Control (RBAC)](/records/architecture/role-based-access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with role-based-access-control", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-role-explosion", "title": "Role Explosion" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The specified interval and procedure by which secrets or keys must be replaced to limit the value of any single compromise.", "term": "Definition", "wide": true }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rotation-policy", "title": "Rotation Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to store, transmit, and use credentials without exposing them.", "term": "Definition", "wide": true }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-credential-handling", "title": "Safe Credential Handling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to display untrusted data without allowing it to execute as markup or script.", "term": "Definition", "wide": true }, { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Output Encoding](/records/architecture/output-encoding)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-rendering", "title": "Safe Rendering" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for running untrusted code with only the resources and permissions it is granted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Runtime Code Generation](/records/architecture/runtime-code-generation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sandboxing", "title": "Sandboxing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing credentials on a schedule and after any exposure, so a leaked secret stops working.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secret Sprawl](/records/architecture/secret-sprawl), [Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-secret-rotation", "title": "Secret Rotation" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A dedicated, access-controlled repository that holds credentials and keys outside of application code.", "term": "Definition", "wide": true }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-secret-store", "title": "Secret Store" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to exchange data over a channel protected from interception and tampering.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-secure-communication", "title": "Secure Communication" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system's settings and secrets are arranged to minimize exposure.", "term": "Definition", "wide": true }, { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Secrets Management](/records/architecture/secrets-management)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-secure-configuration", "title": "Secure Configuration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Deferring security concerns until late in development, when vulnerabilities are costly and difficult to remediate.", "term": "Definition", "wide": true }, { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Security by Design](/records/architecture/security-by-design)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-security-as-afterthought", "title": "Security as Afterthought" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for enforcing every security rule on the server, whatever the client checks.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Security Theater](/records/architecture/security-theater)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-server-side-enforcement", "title": "Server-Side Enforcement" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Depending on one security control with no layered defenses, so a single bypass compromises the whole system.", "term": "Definition", "wide": true }, { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Defense in Depth](/records/architecture/defense-in-depth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-control-reliance", "title": "Single Control Reliance" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which delivery proceeds rapidly, in tension with the caution that managing risk requires.", "term": "Definition", "wide": true }, { "description": "[Risk Management](/records/architecture/risk-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with risk-management", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-speed", "title": "Speed" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Assembling SQL queries by concatenating untrusted input into strings, opening the system to SQL injection.", "term": "Definition", "wide": true }, { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Parameterized Queries](/records/architecture/parameterized-queries)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-string-concatenated-sql", "title": "String-Concatenated SQL" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that every actor prove a strong, verified identity before any access is granted.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-identity", "title": "Strong Identity" }, { "blocks": [ { "items": [ "Kind: [metric](/records/kind/metric)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The rate at which a team delivers completed work, which governance overhead can slow.", "term": "Definition", "wide": true }, { "description": "[Governance](/records/architecture/governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with governance", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-team-velocity", "title": "Team Velocity" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Concrete descriptions of how an attacker might attempt to compromise a system, enumerated during threat modeling.", "term": "Definition", "wide": true }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-threat-scenarios", "title": "Threat Scenarios" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Transport-layer protocols that encrypt a connection and, with mutual TLS, mutually authenticate both endpoints.", "term": "Definition", "wide": true }, { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Encryption in Transit](/records/architecture/encryption-in-transit)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tls-mtls", "title": "TLS/mTLS" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The demarcations in a system where the level of trust changes and data crossing them must be validated.", "term": "Definition", "wide": true }, { "description": "[Threat Modeling](/records/architecture/threat-modeling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Security by Design](/records/architecture/security-by-design), [Threat Modeling](/records/architecture/threat-modeling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trust-boundaries", "title": "Trust Boundaries" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming that traffic originating inside the network perimeter is inherently trustworthy, ignoring insider and lateral-movement threats.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trusted-internal-network-assumption", "title": "Trusted Internal Network Assumption" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Accepting external input as well-formed and safe without validating it, exposing the system to malformed or malicious data.", "term": "Definition", "wide": true }, { "description": "[Input Validation](/records/architecture/input-validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Schema Validation](/records/architecture/schema-validation), [Input Validation](/records/architecture/input-validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-trusting-external-input", "title": "Trusting External Input" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Allowing an actor or component to act without governance limits, so unsafe or unauthorized actions go unchecked.", "term": "Definition", "wide": true }, { "description": "[Governance](/records/architecture/governance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agentic Architecture](/records/architecture/agentic-architecture), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-autonomy", "title": "Unbounded Autonomy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Permitting changes to a controlled system without review, approval, or record, undermining compliance and traceability.", "term": "Definition", "wide": true }, { "description": "[Compliance](/records/architecture/compliance)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Compliance](/records/architecture/compliance), [Governance](/records/architecture/governance)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uncontrolled-change", "title": "Uncontrolled Change" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Exposing more endpoints, ports, or interfaces publicly than the function requires, enlarging the attack surface.", "term": "Definition", "wide": true }, { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Attack Surface Reduction](/records/architecture/attack-surface-reduction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unnecessary-public-surface", "title": "Unnecessary Public Surface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Permitting access to a resource with no controls, so any caller can invoke any operation.", "term": "Definition", "wide": true }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Authorization](/records/architecture/authorization), [Access Control](/records/architecture/access-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unrestricted-access", "title": "Unrestricted Access" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The ease with which users can accomplish their goals with a system.", "term": "Definition", "wide": true }, { "description": "[Access Control](/records/architecture/access-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with access-control", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-usability", "title": "Usability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system minimizes friction and effort for its users.", "term": "Definition", "wide": true }, { "description": "[Session Management](/records/architecture/session-management)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with session-management", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-user-convenience", "title": "User Convenience" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "Declared constraints that input must satisfy, such as type, range, format and length, before it is accepted.", "term": "Definition", "wide": true }, { "description": "[Input Validation](/records/architecture/input-validation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Input Validation](/records/architecture/input-validation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-validation-rules", "title": "Validation Rules" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Security Privacy Compliance](/records/lexicon-category/security-privacy-compliance)", "Layer: [Security Core](/records/layer/security-core)" ], "kind": "list" }, { "entries": [ { "description": "A security stance that grants no implicit trust and continuously verifies every access request regardless of its source.", "term": "Definition", "wide": true }, { "description": "[Zero Trust Architecture](/records/architecture/zero-trust-architecture)", "term": "Principle" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Least Privilege](/records/architecture/least-privilege)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-zero-trust", "title": "Zero Trust" } ], "title": "Security Privacy Compliance" }, { "icon": "bi-book", "id": "lexicon-category-self-healing-recovery-deployment-safety", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for turning repeated manual operational steps into a script the system runs and logs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Runbook Dependency](/records/architecture/manual-runbook-dependency), [Auto-Remediation](/records/architecture/auto-remediation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automate-the-runbook", "title": "Automate the Runbook" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring the load signals and limits by which the number of instances grows and shrinks.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Backpressure](/records/architecture/backpressure), [Elasticity](/records/architecture/elasticity), [Auto-Scaling](/records/architecture/auto-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-autoscaling-policy", "title": "Autoscaling Policy" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for copying data to separate storage on a schedule, so it can be restored after loss or corruption.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Irreversible Migration](/records/architecture/irreversible-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-backup", "title": "Backup" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Routing traffic to instances without checking their health, so requests hit dead or degraded nodes.", "term": "Definition", "wide": true }, { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blind-routing", "title": "Blind Routing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to close open connections cleanly when a process shuts down.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-connection-cleanup", "title": "Connection Cleanup" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which replicas trail the primary, so reads served from them may return stale data.", "term": "Definition", "wide": true }, { "description": "[Replication](/records/architecture/replication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with replication", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-lag", "title": "Consistency Lag" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a defined policy specify how and when replicas converge to a consistent state.", "term": "Definition", "wide": true }, { "description": "[Replication](/records/architecture/replication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Replication](/records/architecture/replication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-policy", "title": "Consistency Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep serving requests by switching to a standby when the primary fails.", "term": "Definition", "wide": true }, { "description": "[Failover](/records/architecture/failover)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Failover](/records/architecture/failover)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-continuity-during-failure", "title": "Continuity During Failure" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to expose a new version to a small, controlled fraction of traffic first.", "term": "Definition", "wide": true }, { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-controlled-exposure", "title": "Controlled Exposure" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which scaling capacity up and down incurs added cost and cold-start latency.", "term": "Definition", "wide": true }, { "description": "[Auto-Scaling](/records/architecture/auto-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with auto-scaling", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cost-cold-start", "title": "Cost/Cold Start" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which reverting code is constrained by forward data migrations that cannot easily be undone.", "term": "Definition", "wide": true }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with rollback", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-migration-compatibility", "title": "Data Migration Compatibility" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to keep serving data after one or more disks fail, by reconstructing from redundancy.", "term": "Definition", "wide": true }, { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" }, { "description": "[Parity-Based Recovery](/records/lexicon/parity-based-recovery): Disk-failure survival is continuing to serve data after a disk is lost, while parity-based recovery is one way the lost data is rebuilt.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-disk-failure-survival", "title": "Disk-Failure Survival" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing to both the old and the new store and comparing reads during a migration, until the new store is trusted.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Irreversible Migration](/records/architecture/irreversible-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dual-read-and-write", "title": "Dual Read and Write" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to verify a system's resilience empirically by injecting faults and observing recovery.", "term": "Definition", "wide": true }, { "description": "[Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-empirical-resilience-verification", "title": "Empirical Resilience Verification" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for changing a schema in steps, adding the new shape, moving every reader and writer, then removing the old shape.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Irreversible Migration](/records/architecture/irreversible-migration), [Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-expand-contract-migration", "title": "Expand-Contract Migration" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to recover quickly from a bad release by reverting to the last good version.", "term": "Definition", "wide": true }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fast-failure-recovery", "title": "Fast Failure Recovery" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Provisioning a fixed, preset amount of capacity, rather than adapting it to demand.", "term": "Definition", "wide": true }, { "description": "[Auto-Scaling](/records/architecture/auto-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with auto-scaling", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fixed-capacity", "title": "Fixed Capacity" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Terminating a process abruptly without draining work, dropping in-flight requests and risking corrupt state.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hard-process-kill", "title": "Hard Process Kill" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect that a component has failed so a switchover can be triggered.", "term": "Definition", "wide": true }, { "description": "[Failover](/records/architecture/failover)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Failover](/records/architecture/failover)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-health-detection", "title": "Health Detection" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A machine-readable signal that reports whether a component is currently healthy, or that a fault or anomaly in it has been detected.", "term": "Definition", "wide": true }, { "description": "Detection Signal", "term": "Aliases" }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-health-signal", "title": "Health Signal" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a system can grow by adding more interchangeable instances rather than enlarging one.", "term": "Definition", "wide": true }, { "description": "[Auto-Scaling](/records/architecture/auto-scaling)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auto-Scaling](/records/architecture/auto-scaling)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-horizontal-scalability", "title": "Horizontal Scalability" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to finish or safely hand off in-progress work before a process exits.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" }, { "description": "[Connection Cleanup](/records/lexicon/connection-cleanup): Draining finishes or hands off work in progress, while connection cleanup closes the open connections.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-in-flight-work-drain", "title": "In-Flight Work Drain" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Upgrading by mutating the running environment in place, with no parallel target to cut over to or fall back from.", "term": "Definition", "wide": true }, { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-in-place-mutation-only", "title": "In-Place Mutation Only" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reduce the number of incidents that reach human responders by fixing them automatically.", "term": "Definition", "wide": true }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" }, { "description": "[Reduced Mean Time to Recovery](/records/lexicon/reduced-mean-time-to-recovery): Incident reduction lowers how many incidents reach a responder, while reduced mean time to recovery shortens each one that happens.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incident-reduction", "title": "Incident Reduction" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which running two full parallel environments doubles infrastructure cost during a cutover.", "term": "Definition", "wide": true }, { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with blue-green-deployment", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-infrastructure-cost", "title": "Infrastructure Cost" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Deploying in a way that cannot be undone, so a bad release cannot be rolled back.", "term": "Definition", "wide": true }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" }, { "description": "[Irreversible Migration](/records/architecture/irreversible-migration): An irreversible deployment cannot roll back a release, while an irreversible migration cannot roll back a schema or data change.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-irreversible-deployment", "title": "Irreversible Deployment" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a process receive lifecycle signals telling it when to start draining and stop.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lifecycle-signals", "title": "Lifecycle Signals" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to switch traffic to a new version with low risk by keeping the old one ready to fall back to.", "term": "Definition", "wide": true }, { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-low-risk-cutover", "title": "Low-Risk Cutover" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Recovering from incidents through human-operated fixes, rather than automated remediation.", "term": "Definition", "wide": true }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with auto-remediation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-manual-remediation", "title": "Manual Remediation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that data span several physical disks so redundancy can survive a single-disk loss.", "term": "Definition", "wide": true }, { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multiple-physical-disks", "title": "Multiple Physical Disks" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that explicit, observable criteria define when a component counts as healthy.", "term": "Definition", "wide": true }, { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-observable-health-criteria", "title": "Observable Health Criteria" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that two full production-equivalent environments run side by side for cutover.", "term": "Definition", "wide": true }, { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Blue-Green Deployment](/records/architecture/blue-green-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-environments", "title": "Parallel Environments" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to reconstruct lost data from parity information stored across the disk array.", "term": "Definition", "wide": true }, { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parity-based-recovery", "title": "Parity-Based Recovery" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which deliberately injecting faults in production risks causing user-facing incidents.", "term": "Definition", "wide": true }, { "description": "[Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with chaos-engineering", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-production-risk", "title": "Production Risk" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A release strategy that rolls out changes gradually to widening audiences while monitoring for regressions.", "term": "Definition", "wide": true }, { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-progressive-delivery", "title": "Progressive Delivery" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to serve more read traffic by distributing it across replicas.", "term": "Definition", "wide": true }, { "description": "[Replication](/records/architecture/replication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Replication](/records/architecture/replication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-scaling", "title": "Read Scaling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to route traffic only to instances that report themselves ready and alive.", "term": "Definition", "wide": true }, { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Health Checks](/records/architecture/health-checks)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-readiness-liveness-routing", "title": "Readiness/Liveness Routing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring, per failure class, the action the system takes to restore service and who is told.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Log-as-Control-Flow](/records/architecture/log-as-control-flow), [Self-Healing Architecture](/records/architecture/self-healing-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-recovery-policy", "title": "Recovery Policy" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to shorten the mean time to recover from a failure by acting automatically.", "term": "Definition", "wide": true }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reduced-mean-time-to-recovery", "title": "Reduced Mean Time to Recovery" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A defined corrective action, or sequence of steps, carried out to return a system to a healthy state after a fault is detected.", "term": "Definition", "wide": true }, { "description": "Remediation Action", "term": "Aliases" }, { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Auto-Remediation](/records/architecture/auto-remediation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remediation-workflow", "title": "Remediation Workflow" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that duplicate copies or spare capacity exist to take over when a component fails.", "term": "Definition", "wide": true }, { "description": "[Redundancy](/records/architecture/redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Redundancy](/records/architecture/redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replication-or-alternate-capacity", "title": "Replication or Alternate Capacity" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a deployment be structured so it can be safely reverted to a prior version.", "term": "Definition", "wide": true }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reversible-deployment", "title": "Reversible Deployment" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stating before a release how it is undone and testing that the undo works.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big-Bang Release](/records/architecture/big-bang-release), [Irreversible Migration](/records/architecture/irreversible-migration), [Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rollback-plan", "title": "Rollback Plan" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which staging a release in gradual increments adds orchestration complexity.", "term": "Definition", "wide": true }, { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with canary-deployment", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rollout-complexity", "title": "Rollout Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which draining in-flight work before exit lengthens the time a shutdown takes.", "term": "Definition", "wide": true }, { "description": "[Graceful Shutdown](/records/architecture/graceful-shutdown)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with graceful-shutdown", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shutdown-latency", "title": "Shutdown Latency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Keeping only one copy of state, so its loss or unavailability takes down the whole system.", "term": "Definition", "wide": true }, { "description": "[Replication](/records/architecture/replication)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Replication](/records/architecture/replication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-copy-state", "title": "Single Copy State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Depending on a single instance with no standby, so its failure takes down the whole service.", "term": "Definition", "wide": true }, { "description": "[Failover](/records/architecture/failover)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Failover](/records/architecture/failover)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-instance-dependency", "title": "Single Instance Dependency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Storing data on a single disk with no redundancy, so that one disk's failure loses everything.", "term": "Definition", "wide": true }, { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-disk-point-of-failure", "title": "Single-Disk Point of Failure" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for shipping changes in small increments, so each release has a small blast radius.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Big-Bang Release](/records/architecture/big-bang-release), [Evolutionary Architecture](/records/architecture/evolutionary-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-small-batch-release", "title": "Small-Batch Release" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that routes a configurable proportion of traffic to different versions of a service.", "term": "Definition", "wide": true }, { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Canary Deployment](/records/architecture/canary-deployment)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-traffic-splitting", "title": "Traffic Splitting" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which automated remediation may take wrong or harmful corrective actions, for example on a faulty signal, faster than the developer can intervene.", "term": "Definition", "wide": true }, { "description": "Automation Risk, False Recovery Actions", "term": "Aliases" }, { "description": "[Self-Healing Architecture](/records/architecture/self-healing-architecture), [Auto-Remediation](/records/architecture/auto-remediation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with self-healing-architecture, the tension resolution with auto-remediation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unsafe-automation", "title": "Unsafe Automation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "Assuming a system will survive failures without ever testing those assumptions against injected faults.", "term": "Definition", "wide": true }, { "description": "[Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Chaos Engineering](/records/architecture/chaos-engineering)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-untested-failure-assumptions", "title": "Untested Failure Assumptions" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "A build artifact tagged with a distinct version so a prior one can be redeployed.", "term": "Definition", "wide": true }, { "description": "[Rollback](/records/architecture/rollback)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Rollback](/records/architecture/rollback)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-versioned-artifact", "title": "Versioned Artifact" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Self-Healing / Recovery / Deployment Safety](/records/lexicon-category/self-healing-recovery-deployment-safety)", "Layer: [Correctness Core](/records/layer/correctness-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which maintaining parity on writes multiplies the underlying disk writes for each logical write.", "term": "Definition", "wide": true }, { "description": "[RAID Redundancy](/records/architecture/raid-redundancy)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with raid-redundancy", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-write-amplification", "title": "Write Amplification" } ], "title": "Self-Healing / Recovery / Deployment Safety" }, { "icon": "bi-book", "id": "lexicon-category-solid-object-oriented-design", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "Incompatible Override", "term": "Aliases" }, { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-broken-inheritance", "title": "Broken Inheritance" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to give each client an interface exposing only the operations it uses.", "term": "Definition", "wide": true }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consumer-specific-contracts", "title": "Consumer-Specific Contracts" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a subtype honor every behavioral guarantee of the type it replaces.", "term": "Definition", "wide": true }, { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Referenced by" }, { "description": "[Invariant](/records/architecture/invariant): Contract preservation binds a subtype to all of its base type's guarantees, while an invariant is one guarantee that holds in every state.", "term": "Distinct from" }, { "description": "[Postconditions](/records/architecture/postconditions): Contract preservation binds a subtype to every guarantee, while a postcondition is the one an operation gives on return.", "term": "Distinct from" }, { "description": "[Preconditions](/records/architecture/preconditions): Contract preservation binds a subtype to every guarantee, while a precondition is what an operation needs before it runs.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-contract-preservation", "title": "Contract Preservation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring the operations clients use as an interface, so the clients depend on it instead of on the class.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Circular Dependency](/records/architecture/circular-dependency), [Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph), [Explicit Contracts](/records/architecture/explicit-contracts), [Interface-Based Design](/records/architecture/interface-based-design), [Low Coupling](/records/architecture/low-coupling), [Abstraction](/records/architecture/abstraction), [Dependency Inversion Principle (DIP)](/records/architecture/dependency-inversion), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution), [Extension Points](/records/architecture/extension-points), [Clean Architecture](/records/architecture/clean-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-interface", "title": "Extract Interface" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for splitting the operations one client role uses into an interface of their own.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation), [Capability Declaration](/records/architecture/capability-declaration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-extract-role-interface", "title": "Extract Role Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "An interface bundling many unrelated operations, forcing clients to depend on methods they never call.", "term": "Definition", "wide": true }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Referenced by" }, { "description": "[Repository Dump](/records/architecture/repository-dump): A fat interface bundles unrelated operations for its clients, while a repository dump is a repository grown into a second service layer.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fat-interface", "title": "Fat Interface" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add new behavior by writing new code rather than editing existing, tested code.", "term": "Definition", "wide": true }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-feature-extension-without-modification", "title": "Feature Extension without Modification" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which splitting interfaces finely multiplies the number of small interfaces to manage.", "term": "Definition", "wide": true }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with interface-segregation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-interface-proliferation", "title": "Interface Proliferation" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for making a high-level module own an abstraction that a low-level module implements.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concrete Coupling](/records/architecture/concrete-coupling), [Circular Dependency](/records/architecture/circular-dependency), [Dependency Graph](/records/architecture/dependency-graph), [Directed Acyclic Graph (DAG)](/records/architecture/directed-acyclic-graph), [Abstraction](/records/architecture/abstraction), [Modularity](/records/architecture/modularity), [Replaceability](/records/architecture/replaceability)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-invert-dependency", "title": "Invert Dependency" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which honoring a base type's contract constrains a subtype from specializing its own behavior.", "term": "Definition", "wide": true }, { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with liskov-substitution", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-narrow-specialized-behavior", "title": "Narrow Specialized Behavior" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing a subclass with a class that holds the former base as a field and forwards to it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composition Over Inheritance](/records/architecture/composition-over-inheritance), [Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-replace-inheritance-with-delegation", "title": "Replace Inheritance with Delegation" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that interfaces be defined per client role rather than as one general-purpose surface.", "term": "Definition", "wide": true }, { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-role-specific-interfaces", "title": "Role-Specific Interfaces" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a class hierarchy whose subtypes do not honor one contract into hierarchies that each do.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Liskov Substitution Principle (LSP)](/records/architecture/liskov-substitution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-hierarchy", "title": "Split Hierarchy" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a broad interface into smaller ones, each holding operations that change together.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Circular Dependency](/records/architecture/circular-dependency), [Interface Segregation Principle (ISP)](/records/architecture/interface-segregation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-interface", "title": "Split Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Extending behavior by editing a growing switch or conditional on a type instead of adding a new polymorphic type.", "term": "Definition", "wide": true }, { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Open/Closed Principle (OCP)](/records/architecture/open-closed)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-switch-based-extension", "title": "Switch-Based Extension" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [SOLID / Object-Oriented Design](/records/lexicon-category/solid-object-oriented-design)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Branching on an object's concrete type instead of dispatching through a shared polymorphic interface or a visitor's double dispatch.", "term": "Definition", "wide": true }, { "description": "Type-Switch Dispatch", "term": "Aliases" }, { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Polymorphism](/records/architecture/polymorphism), [Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dynamic Dispatch](/records/architecture/dynamic-dispatch), [Polymorphism](/records/architecture/polymorphism), [Visitor Pattern](/records/architecture/visitor-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-type-switching", "title": "Type Switching" } ], "title": "SOLID / Object-Oriented Design" }, { "icon": "bi-book", "id": "lexicon-category-streaming-pipeline-dataflow-processing", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to skip computing results that are never used.", "term": "Definition", "wide": true }, { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-avoiding-unneeded-work", "title": "Avoiding Unneeded Work" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A method that explores options and reverts to an earlier point when one fails, requiring the ability to look back.", "term": "Definition", "wide": true }, { "description": "[Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with forward-only-processing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-backtracking-algorithm", "title": "Backtracking Algorithm" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Processing data in scheduled batches rather than as a continuous low-latency stream.", "term": "Definition", "wide": true }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with streaming-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-batch-only-processing", "title": "Batch-Only Processing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to aggregate an endless stream by grouping its events into bounded windows.", "term": "Definition", "wide": true }, { "description": "[Windowing](/records/architecture/windowing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Windowing](/records/architecture/windowing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-aggregation-over-unbounded-streams", "title": "Bounded Aggregation over Unbounded Streams" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which processing keeps its working state within a fixed bound regardless of input size.", "term": "Definition", "wide": true }, { "description": "[Windowing](/records/architecture/windowing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Windowing](/records/architecture/windowing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-bounded-state", "title": "Bounded State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which forbidding backtracking makes complex grammars or global-state logic hard to express.", "term": "Definition", "wide": true }, { "description": "[Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with forward-only-processing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-complex-grammar-global-state", "title": "Complex Grammar/Global State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A monolith driven by imperative control flow rather than data dependencies, so stages cannot run or scale independently.", "term": "Definition", "wide": true }, { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-control-flow-centric-monolith", "title": "Control-Flow-Centric Monolith" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the data each stage needs from others be declared as explicit dependencies.", "term": "Definition", "wide": true }, { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" }, { "description": "[Stages](/records/lexicon/stages): Data dependencies declare what each stage needs from others, while stages are the discrete steps themselves.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-dependencies", "title": "Data Dependencies" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which deferring computation makes execution order harder to debug and resource lifetimes harder to reason about.", "term": "Definition", "wide": true }, { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with lazy-evaluation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-debuggability-resource-lifetime", "title": "Debuggability/Resource Lifetime" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a computation's semantics defer its work until the result is demanded.", "term": "Definition", "wide": true }, { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deferred-execution-semantics", "title": "Deferred Execution Semantics" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Computing and materializing a complete result up front, rather than deferring computation until parts are needed.", "term": "Definition", "wide": true }, { "description": "[Lazy Evaluation](/records/architecture/lazy-evaluation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with lazy-evaluation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-eager-full-materialization", "title": "Eager Full Materialization" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which splitting work into pipeline stages makes an error harder to trace back to its origin.", "term": "Definition", "wide": true }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pipeline-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-error-propagation-debugging", "title": "Error Propagation/Debugging" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The time at which an event occurred, carried on the event and used to assign it to a window.", "term": "Definition", "wide": true }, { "description": "[Windowing](/records/architecture/windowing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Windowing](/records/architecture/windowing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-event-time", "title": "Event Time" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which the chosen processing model matches the latency and volume the problem needs.", "term": "Definition", "wide": true }, { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fitness-for-purpose", "title": "Fitness for Purpose" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that processing keep only forward-moving state, never needing to revisit earlier input.", "term": "Definition", "wide": true }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-forward-only-state-model", "title": "Forward-Only State Model" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for combining several passes over the same data into one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fuse-passes", "title": "Fuse Passes" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which processing data in a single pass forgoes optimizations that need a full view of the data.", "term": "Definition", "wide": true }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with single-pass-processing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-global-optimization", "title": "Global Optimization" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process datasets larger than memory by reading them in order, a piece at a time.", "term": "Definition", "wide": true }, { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-large-data-processing", "title": "Large Data Processing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which windowing by event time must reckon with events that arrive after their window has closed.", "term": "Definition", "wide": true }, { "description": "[Windowing](/records/architecture/windowing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with windowing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-late-data-handling", "title": "Late-Data Handling" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a workload's latency and freshness needs be made explicit before a processing model is chosen.", "term": "Definition", "wide": true }, { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-requirement-clarity", "title": "Latency Requirement Clarity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to choose batch or stream processing to match a workload's latency needs.", "term": "Definition", "wide": true }, { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-latency-appropriate-processing-model", "title": "Latency-Appropriate Processing Model" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a whole stream is buffered so that one stage can look back or ahead.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-look-back-buffering", "title": "Look-Back Buffering" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which reading strictly in sequence makes locating a specific item by key slow.", "term": "Definition", "wide": true }, { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with sequential-access", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lookup-performance", "title": "Lookup Performance" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "One large function that performs every processing step at once, so stages cannot be tested or reused independently.", "term": "Definition", "wide": true }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-monolithic-processing-function", "title": "Monolithic Processing Function" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Loading a full dataset into memory and traversing it in multiple passes, rather than in a single streaming pass.", "term": "Definition", "wide": true }, { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with single-pass-processing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multi-pass-full-materialization", "title": "Multi-Pass Full Materialization" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a processor keep no state between invocations, so each call starts afresh from what it is given.", "term": "Definition", "wide": true }, { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-no-hidden-state", "title": "No Hidden State" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Forcing every workload through a single processing model regardless of its latency or volume needs.", "term": "Definition", "wide": true }, { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-one-size-fits-all-processing", "title": "One-Size-Fits-All Processing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which supporting both batch and streaming paths duplicates operational effort and code.", "term": "Definition", "wide": true }, { "description": "[Batch-vs-Stream](/records/architecture/batch-vs-stream)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with batch-vs-stream", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-operational-duplication", "title": "Operational Duplication" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that data be read in a fixed forward order rather than by arbitrary index.", "term": "Definition", "wide": true }, { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordered-read-model", "title": "Ordered Read Model" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which processing an unbounded stream complicates preserving event order and bounded state.", "term": "Definition", "wide": true }, { "description": "[Streaming Architecture](/records/architecture/streaming-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with streaming-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordering-state", "title": "Ordering/State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process independent branches of work simultaneously across workers.", "term": "Definition", "wide": true }, { "description": "[Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" }, { "description": "[Result Aggregation](/records/lexicon/result-aggregation): Parallel branch processing fans work out, while result aggregation brings the outputs back into one.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-branch-processing", "title": "Parallel Branch Processing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process many records at once because each is handled independently of the others.", "term": "Definition", "wide": true }, { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-processing", "title": "Parallel Processing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to run independent stages in parallel or stream data between them as it is produced.", "term": "Definition", "wide": true }, { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-parallel-stream-processing", "title": "Parallel/Stream Processing" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which code seeks or indexes into a source that can only be read in sequence.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-random-access-over-a-stream", "title": "Random Access over a Stream" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A need to read arbitrary items by position or key on demand rather than strictly in sequence.", "term": "Definition", "wide": true }, { "description": "[Sequential Access](/records/architecture/sequential-access)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with sequential-access", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-random-access-requirement", "title": "Random Access Requirement" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which large data is scanned or materialized several times where one pass would do.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Single-Pass Processing](/records/architecture/single-pass-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repeated-full-scan", "title": "Repeated Full Scan" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to combine the outputs of parallel branches back into a single result.", "term": "Definition", "wide": true }, { "description": "[Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-result-aggregation", "title": "Result Aggregation" }, { "blocks": [ { "items": [ "Kind: [approach](/records/kind/approach)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Processing independent items one at a time in sequence, rather than in parallel.", "term": "Definition", "wide": true }, { "description": "[Fan-out/Fan-in](/records/architecture/fan-out-fan-in)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with fan-out-fan-in", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-serial-item-processing", "title": "Serial Item Processing" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that each pipeline stage declare a typed contract for what it consumes and produces.", "term": "Definition", "wide": true }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stage-contracts", "title": "Stage Contracts" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that processing be decomposed into discrete stages connected by data flow.", "term": "Definition", "wide": true }, { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stages", "title": "Stages" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a data-driven design must still coordinate shared state across concurrent stages.", "term": "Definition", "wide": true }, { "description": "[Dataflow Architecture](/records/architecture/dataflow-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with dataflow-architecture", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-coordination", "title": "State Coordination" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which rules that inherently depend on accumulated state resist a purely stateless design.", "term": "Definition", "wide": true }, { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with stateless-processing", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stateful-business-rules", "title": "Stateful Business Rules" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Accumulating state inside a processor across records, so results depend on invisible history.", "term": "Definition", "wide": true }, { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Stateless Processing](/records/architecture/stateless-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stateful-hidden-accumulation", "title": "Stateful Hidden Accumulation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to transform data through a sequence of small, composable stages.", "term": "Definition", "wide": true }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stepwise-transformation", "title": "Stepwise Transformation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to process data continuously as it arrives rather than in complete batches.", "term": "Definition", "wide": true }, { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pipeline Architecture](/records/architecture/pipeline-architecture)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-streaming", "title": "Streaming" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to parse input incrementally as it streams in, without buffering the whole document.", "term": "Definition", "wide": true }, { "description": "[Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Forward-Only Processing](/records/architecture/forward-only-processing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-streaming-parsers", "title": "Streaming Parsers" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Streaming / Pipeline / Dataflow Processing](/records/lexicon-category/streaming-pipeline-dataflow-processing)", "Layer: [Execution Core](/records/layer/execution-core)" ], "kind": "list" }, { "entries": [ { "description": "Aggregating an endless stream into ever-growing state that eventually exhausts memory.", "term": "Definition", "wide": true }, { "description": "[Windowing](/records/architecture/windowing)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Windowing](/records/architecture/windowing)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unbounded-accumulation", "title": "Unbounded Accumulation" } ], "title": "Streaming / Pipeline / Dataflow Processing" }, { "icon": "bi-book", "id": "lexicon-category-structural-patterns", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Modeling every combination of two independent dimensions as its own subclass, so the class count grows multiplicatively.", "term": "Definition", "wide": true }, { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-cartesian-inheritance-explosion", "title": "Cartesian Inheritance Explosion" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a wrapper and the object it wraps share one interface so they remain interchangeable.", "term": "Definition", "wide": true }, { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-common-interface", "title": "Common Interface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Reaching a resource directly with no intermediary, bypassing the access control, caching, or laziness a proxy would add.", "term": "Definition", "wide": true }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-access", "title": "Direct Access" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Coupling code directly to an incompatible external interface, spreading its idiosyncrasies through the codebase.", "term": "Definition", "wide": true }, { "description": "[Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Anti-Corruption Layer](/records/architecture/anti-corruption-layer), [Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-direct-external-coupling", "title": "Direct External Coupling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to represent large numbers of similar objects economically by sharing their common intrinsic state.", "term": "Definition", "wide": true }, { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-high-cardinality-object-reuse", "title": "High-Cardinality Object Reuse" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to change an abstraction's underlying implementation without altering the abstraction itself.", "term": "Definition", "wide": true }, { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-implementation-swap", "title": "Implementation Swap" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A precondition of two interfaces that must cooperate yet expose mismatched signatures.", "term": "Definition", "wide": true }, { "description": "[Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Adapter Pattern](/records/architecture/adapter-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-incompatible-interfaces", "title": "Incompatible Interfaces" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an abstraction and its implementation vary along separate axes so they can be decoupled.", "term": "Definition", "wide": true }, { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-independent-variation-axes", "title": "Independent Variation Axes" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of extra indirection introduced by separating an abstraction from its implementation.", "term": "Definition", "wide": true }, { "description": "[Bridge Pattern](/records/architecture/bridge-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with bridge-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-indirection", "title": "Indirection" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to defer creating or loading a costly resource until it is first used.", "term": "Definition", "wide": true }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lazy-load", "title": "Lazy Load" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Branching client code on whether an element is a leaf or a container instead of treating them through one interface.", "term": "Definition", "wide": true }, { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-leaf-vs-container-special-casing", "title": "Leaf-vs-Container Special-Casing" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to treat individual objects and compositions of objects through one uniform interface.", "term": "Definition", "wide": true }, { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-leaf-composite-transparency", "title": "Leaf/Composite Transparency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Exposing a subsystem's internal complexity directly to clients instead of hiding it behind a simplifying interface.", "term": "Definition", "wide": true }, { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-leaky-subsystem-api", "title": "Leaky Subsystem API" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which routing all access through one facade concentrates responsibility and can bottleneck change.", "term": "Definition", "wide": true }, { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with facade-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-over-centralization", "title": "Over-Centralization" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Storing identical shared state separately in every object instance, wasting memory at high object counts.", "term": "Definition", "wide": true }, { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-per-instance-duplicate-state", "title": "Per-Instance Duplicate State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to build tree structures in which composites contain other composites to arbitrary depth.", "term": "Definition", "wide": true }, { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" }, { "description": "[Leaf/Composite Transparency](/records/lexicon/leaf-composite-transparency): Recursive composition nests composites to any depth, while leaf and composite transparency lets callers treat both through one interface.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-recursive-composition", "title": "Recursive Composition" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "A local stand-in object that forwards calls to an object living in another process or machine.", "term": "Definition", "wide": true }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remote-stub", "title": "Remote Stub" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to add responsibilities to an object dynamically at runtime by wrapping it.", "term": "Definition", "wide": true }, { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-runtime-behavior-extension", "title": "Runtime Behavior Extension" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an object's shared, context-independent state be separable from its per-use state.", "term": "Definition", "wide": true }, { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-separable-intrinsic-state", "title": "Separable Intrinsic State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to safely share one immutable state object across many contexts at once.", "term": "Definition", "wide": true }, { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Referenced by" }, { "description": "[High-Cardinality Object Reuse](/records/lexicon/high-cardinality-object-reuse): Shared immutable state is one object safely used in many contexts, while high-cardinality reuse represents many similar objects cheaply through that sharing.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flyweight Pattern](/records/architecture/flyweight-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-immutable-state", "title": "Shared Immutable State" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The ability to use a complex subsystem through a small, convenient interface.", "term": "Definition", "wide": true }, { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-simplified-access", "title": "Simplified Access" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which layers of wrapping deepen the call stack and complicate debugging.", "term": "Definition", "wide": true }, { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with decorator-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stack-debugging", "title": "Stack Debugging" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "Creating a distinct subclass for every combination of optional features instead of composing them at runtime.", "term": "Definition", "wide": true }, { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Decorator Pattern](/records/architecture/decorator-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subclass-explosion", "title": "Subclass Explosion" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree of internal complexity in a subsystem that motivates hiding it behind a facade.", "term": "Definition", "wide": true }, { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Facade Pattern](/records/architecture/facade-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subsystem-complexity", "title": "Subsystem Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which interposing a proxy hides the real object and complicates tracing calls to it.", "term": "Definition", "wide": true }, { "description": "[Proxy Pattern](/records/architecture/proxy-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with proxy-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transparency-debugging", "title": "Transparency / Debugging" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Structural Patterns](/records/lexicon-category/structural-patterns)", "Layer: [Design Patterns Core](/records/layer/design-patterns-core)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that leaves and composites implement one shared interface so clients treat them alike.", "term": "Definition", "wide": true }, { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Composite Pattern](/records/architecture/composite-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-uniform-component-interface", "title": "Uniform Component Interface" } ], "title": "Structural Patterns" }, { "icon": "bi-book", "id": "lexicon-category-taxonomy-classification-naming", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for relieving breadth with a subject folder beside the existing one instead of below it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-add-a-sibling-subject-folder", "title": "Add a Sibling Subject Folder" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Admitting an adjective such as lazy, bounded or shallow into a name slot, where no category can take it, so it describes a file without classifying it.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" }, { "description": "[Instance Identifier Word](/records/lexicon/instance-identifier-word): An adjective describes a file without naming a kind, while an instance identifier names one entry instead of a kind.", "term": "Distinct from" }, { "description": "[Measurement Word](/records/lexicon/measurement-word): An adjective is a quality of a file, while a measurement word is data a file holds.", "term": "Distinct from" }, { "description": "[Plural Subject](/records/lexicon/plural-subject): An adjective is the wrong part of speech for any slot, while a plural subject is the right part of speech in the wrong number.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-adjective-slot-word", "title": "Adjective Slot Word" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about one whole reading of a conversion protocol, carrying the content hash of the revision read and the scope it covers, which every conversion record written after it cites.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" }, { "description": "[Frozen Baseline](/records/lexicon/frozen-baseline): An alignment entry records one reading of the protocol, while the frozen baseline records which files already conformed when the gate shipped.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-alignment-entry", "title": "Alignment Entry" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for resolving an irreducible two-concern overlap toward the concern nearer the domain on the layer spine.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-apply-the-domain-ward-tie-break", "title": "Apply the Domain-Ward Tie-Break" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Renaming by tool across a tree holding shape-discovered surfaces, so the rewrite reports clean while an aggregator that collected by suffix now collects nothing.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration), [Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration), [Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-automated-reshape", "title": "Automated Reshape" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Deciding whether two declared words overlap from a general-language corpus rather than from the roles they name, so distinct concerns collide on their everyday senses and domain overlaps go unseen.", "term": "Definition", "wide": true }, { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-borrowed-synonymy", "title": "Borrowed Synonymy" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Declaring a tree that another runtime resolves by name a governed root and renaming it to the grammar, which breaks that runtime at its next start without reorganizing anything.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-claimed-foreign-tree", "title": "Claimed Foreign Tree" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of reading a file and assigning its concern by its primary responsibility, which no pattern-match can perform on its behalf.", "term": "Definition", "wide": true }, { "description": "[One Concern Per File](/records/architecture/one-concern-per-file), [Narrowest Concern](/records/architecture/narrowest-concern), [Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[One Concern Per File](/records/architecture/one-concern-per-file), [Narrowest Concern](/records/architecture/narrowest-concern), [Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-classification-judgment", "title": "Classification Judgment" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deciding a file's concern and subject before writing it, so it is created under its final name.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-classify-before-the-first-write", "title": "Classify Before the First Write" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for tagging a file with the agnostic concern that covers its role instead of a domain word.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-classify-to-the-meta-concern", "title": "Classify to the Meta Concern" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing per-check exemption lists for one upstream tree with a single declaration every check reads.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-collapse-the-exemption-lists", "title": "Collapse the Exemption Lists" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a concern whose file defines many members at once, plural in both the folder label and the file tag.", "term": "Definition", "wide": true }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Referenced by" }, { "description": "[Single-Unit Concern](/records/lexicon/single-unit-concern): A collection concern's file defines many members and its tag is plural, while a single-unit concern's file defines one and its tag is singular.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-collection-concern", "title": "Collection Concern" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for comparing the responsibilities of two colliding files before giving either a variant.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Collision Consolidation](/records/architecture/collision-consolidation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compare-both-files", "title": "Compare Both Files" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the declared words, such as test, generated or rule, that exempt a filename from the naming grammar when they sit just before the extension, while the file's placement stays governed.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Referenced by" }, { "description": "[Ecosystem-Fixed Name](/records/lexicon/ecosystem-fixed-name): A compound marker exempts a filename by a declared word before its extension, while an ecosystem-fixed name is exempt because a tool finds it by exact name.", "term": "Distinct from" }, { "description": "[Ignore Declaration](/records/lexicon/ignore-declaration): A compound marker exempts the name and keeps the placement governed, while the ignore declaration removes a name from the taxonomy entirely.", "term": "Distinct from" }, { "description": "[Structurally Exempt File](/records/lexicon/structurally-exempt-file): A compound marker is a word in the filename, while a structurally exempt file is exempt because of how it is resolved.", "term": "Distinct from" }, { "description": "[Test Tag](/records/lexicon/test-tag): A compound marker is the class of exempting words, while the test marker is one of them.", "term": "Distinct from" }, { "description": "[Tests](/records/lexicon/tests): A compound marker is a filename word, while tests are the executable checks a test file holds.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-compound-marker", "title": "Compound Marker" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that holds every file of one concern and whose label the file's concern tag must equal.", "term": "Definition", "wide": true }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Mirrored Test Placement](/records/architecture/mirrored-test-placement), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Mirrored Test Placement](/records/architecture/mirrored-test-placement), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concern-folder", "title": "Concern Folder" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the role a file plays, drawn from the closed concern vocabulary and carried as the last dot-segment before the extension.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Referenced by" }, { "description": "[Collection Concern](/records/lexicon/collection-concern): A concern tag is any role word in the concern slot, while a collection concern is the plural form of one.", "term": "Distinct from" }, { "description": "[Mass Concern](/records/lexicon/mass-concern): A concern tag is any role word, while a mass concern is the uncountable, singular form of one.", "term": "Distinct from" }, { "description": "[Single-Unit Concern](/records/lexicon/single-unit-concern): A concern tag is any role word, while a single-unit concern is the form with one instance per file.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concern-tag", "title": "Concern Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Fusing a subject and a concern into one word, so the tag that should terminate the name is buried inside it and no glob resolves the file.", "term": "Definition", "wide": true }, { "description": "Compound That Swallowed a Concern", "term": "Aliases" }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" }, { "description": "[Free-Form Folder Level](/records/lexicon/free-form-folder-level): A concern-swallowing compound hides a filename's tag inside one word, while a free-form folder level is a folder whose word resolves to nothing.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concern-swallowing-compound", "title": "Concern-Swallowing Compound" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that partitions a governed root by grouping axis, declared as a closed set and anchoring the depth count at level one.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Flat Bucket](/records/lexicon/flat-bucket): A container level partitions a root and holds folders, while a flat bucket holds files of one concern and no folders.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-container-level", "title": "Container Level" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The practice of converting one container at a time to the taxonomy, updating every reference in the same pass and holding the gate green between each.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-container-by-container-reshape", "title": "Container-by-Container Reshape" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the record written for each file a conversion names, holding its responsibilities with the symbols behind them, its chosen concern and subject, the candidates refused, and the verdict on any file that shares its job.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" }, { "description": "[Alignment Entry](/records/lexicon/alignment-entry): A conversion record is written per converted file, while an alignment entry is written per reading of the protocol, and the records cite it.", "term": "Distinct from" }, { "description": "[Frozen Baseline](/records/lexicon/frozen-baseline): A conversion record is owed by each file converted, while the frozen baseline lists the files that owe none.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-conversion-record", "title": "Conversion Record" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which each word a source owns is copied into the declared vocabulary, one entry per allocated identity or upstream key.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-copied-slot-word", "title": "Copied Slot Word" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for fixing a slot resolver that reads a word by its vocabulary instead of by its position.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-correct-the-resolver", "title": "Correct the Resolver" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of the declared word that already fills a proposed word's role, resolved from the rejection table so a refusal carries its own replacement.", "term": "Definition", "wide": true }, { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-covering-concern", "title": "Covering Concern" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for binding a file extension to the case splitter its language uses.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-dialect", "title": "Declare the Dialect" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for adding a folder to the jurisdiction declaration instead of inferring that it is governed.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-declare-the-root", "title": "Declare the Root" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that every governed file resolve within a fixed number of folders from its governed root, the container included and the file excluded.", "term": "Definition", "wide": true }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Referenced by" }, { "description": "[Ordered Role Sequence](/records/lexicon/ordered-role-sequence): The depth cap limits how many folders a path has, while the ordered role sequence limits the order of their roles.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-depth-cap", "title": "Depth Cap" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which discovery is anchored to a depth, so a grouped set falls out of the pattern.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-depth-anchored-discovery", "title": "Depth-Anchored Discovery" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Declaring a container to shorten a path or to house files that resist placement, turning the level that anchors the depth count into an escape from it.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Claimed Foreign Tree](/records/lexicon/claimed-foreign-tree): A depth-relief container declares a new container inside the grammar, while a claimed foreign tree brings another runtime's tree under it.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-depth-relief-container", "title": "Depth-Relief Container" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for generating the machine-read vocabulary from the document that reasons about it, so the two cannot drift.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-derive-the-registry-from-the-document", "title": "Derive the Registry from the Document" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which an agnostic role is restated in a local domain dialect.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-domain-dialect-role", "title": "Domain-Dialect Role" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Relieving collision or breadth pressure by adding a folder level, breaking the depth cap that both overflow slots exist to protect.", "term": "Definition", "wide": true }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-downward-nesting", "title": "Downward Nesting" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing a numeric order prefix from filenames once a registry holds the order.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry-Held Order](/records/architecture/registry-held-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-drop-the-prefix", "title": "Drop the Prefix" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing from a filename the subject its folder already declares.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-drop-the-redundant-head", "title": "Drop the Redundant Head" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the filenames an external tool finds by exact name, such as package manifests, lockfiles and compiler configurations, which are never renamed to the grammar.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Structurally Exempt File](/records/lexicon/structurally-exempt-file): An ecosystem-fixed name is found by an external tool by exact name, while a structurally exempt file is resolved by the project's own shape, entry map or generator.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ecosystem-fixed-name", "title": "Ecosystem-Fixed Name" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that holds one collection concern as files with no folders beneath it, declared rather than inferred from shape.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-flat-bucket", "title": "Flat Bucket" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A folder level resolving to no declared word, so the path is conventional rather than checkable and classification has more than one right answer.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-free-form-folder-level", "title": "Free-Form Folder Level" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the files already conformant when a conversion's record gate shipped, pinned once into a generated set that never grows, so only a file renamed or moved afterwards owes a record.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-frozen-baseline", "title": "Frozen Baseline" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a file carries the generic subject while its source names the domain it serves.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-generic-subject-over-a-domain-file", "title": "Generic Subject over a Domain File" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which one depth-unanchored pattern resolves every file or every folder of a concern across the whole tree.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Sideways Overflow](/records/architecture/sideways-overflow), [Registry-Held Order](/records/architecture/registry-held-order), [Externally Resolved Slot](/records/architecture/externally-resolved-slot), [Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence), [Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Sideways Overflow](/records/architecture/sideways-overflow), [Registry-Held Order](/records/architecture/registry-held-order), [Externally Resolved Slot](/records/architecture/externally-resolved-slot), [Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-glob-resolvability", "title": "Glob Resolvability" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that a path falls under the taxonomy only where its root is declared, so an undeclared tree is ungoverned and a declared one is governed in full.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Conformance at Creation](/records/architecture/conformance-at-creation), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction), [Conformance at Creation](/records/architecture/conformance-at-creation), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-governed-root", "title": "Governed Root" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Using a bucket word such as misc, common, shared or core as a subject, which excludes no file and so classifies none, although grouping is exactly what a container is for.", "term": "Definition", "wide": true }, { "description": "[Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-grouping-label", "title": "Grouping Label" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of renaming an artifact and updating every reference to it in the same pass, so no reference is left dangling.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration), [Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Referenced by" }, { "description": "[Unreferenced Export Triage](/records/lexicon/unreferenced-export-triage): Identity migration renames and updates every reference, while export triage decides what to do with an export nothing references.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration), [Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-identity-migration", "title": "Identity Migration" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the names skipped wherever they appear under a governed root, covering build output, vendored sources, tool caches and ecosystem-fixed names.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Ecosystem-Fixed Name](/records/lexicon/ecosystem-fixed-name): The ignore declaration is the list of skipped names, while an ecosystem-fixed name is one class of name it may list.", "term": "Distinct from" }, { "description": "[Structurally Exempt File](/records/lexicon/structurally-exempt-file): The ignore declaration removes names from the taxonomy, while a structurally exempt file stays placed and is exempt only from naming.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ignore-declaration", "title": "Ignore Declaration" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Answering a finding by adding the path to the ignore declaration, removing authored source from the taxonomy entirely and hiding every future violation under the same name.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" }, { "description": "[Claimed Foreign Tree](/records/lexicon/claimed-foreign-tree): Ignore-list silencing takes authored source out of the taxonomy, while a claimed foreign tree puts another system's tree into it.", "term": "Distinct from" }, { "description": "[Depth-Relief Container](/records/lexicon/depth-relief-container): Ignore-list silencing escapes a finding by removal, while a depth-relief container escapes it by declaring a new level.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ignore-list-silencing", "title": "Ignore-List Silencing" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for keying the table of rejected words by the refused word, so the gate can look up its replacement.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-index-the-rejection-table-by-refused-word", "title": "Index the Rejection Table by Refused Word" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Admitting the id of one registry entry, such as primary or dark-mode, into a vocabulary, so content enters a list that should hold only kinds of thing.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-instance-identifier-word", "title": "Instance Identifier Word" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "[Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-is-a-test", "title": "Is-A Test" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A conceptual representation of the system-decomposition spectrum that totally orders every concern from domain through product and supplies the tie-break direction.", "term": "Definition", "wide": true }, { "description": "[Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-layer-spine", "title": "Layer Spine" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a file sits at a governed root while it is neither the entry document nor an accumulator.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-loose-root-file", "title": "Loose Root File" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a concern named for an uncountable role, singular in both the folder label and the file tag, as a configuration or a state is.", "term": "Definition", "wide": true }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Referenced by" }, { "description": "[Collection Concern](/records/lexicon/collection-concern): A mass concern is uncountable and singular in folder and tag, while a collection concern is plural in both.", "term": "Distinct from" }, { "description": "[Single-Unit Concern](/records/lexicon/single-unit-concern): A mass concern is singular in folder and tag, while a single-unit concern pairs a plural folder with a singular tag.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "[Collection Concern](/records/lexicon/collection-concern), [Single-Unit Concern](/records/lexicon/single-unit-concern)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-mass-concern", "title": "Mass Concern" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Admitting a measurement or property such as duration, interval or budget as a vocabulary word, where it names data held in a file rather than a role or a thing.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" }, { "description": "[Instance Identifier Word](/records/lexicon/instance-identifier-word): A measurement word names a quantity a file holds, while an instance identifier names one entry of a registry.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-measurement-word", "title": "Measurement Word" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for merging two files that do one job, or giving the variant the facet that truly differs.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Collision Consolidation](/records/architecture/collision-consolidation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-merge-one-job-or-name-the-facet", "title": "Merge One Job or Name the Facet" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving rules written into a declaration file back into the document that people read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-reasoning-back-to-the-document", "title": "Move Reasoning Back to the Document" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a loose root file into the concern folder its tag names.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-the-file-into-its-concern-folder", "title": "Move the File into Its Concern Folder" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for recording a sequence in a registry instead of in numeric filename prefixes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry-Held Order](/records/architecture/registry-held-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-the-order-into-the-registry", "title": "Move the Order into the Registry" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for placing a concern tag as the last segment of a filename, where the parser reads the concern.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-the-tag-to-the-concern-slot", "title": "Move the Tag to the Concern Slot" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a test to the mirrored path of its subject whenever the subject moves.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-the-test-with-its-subject", "title": "Move the Test with Its Subject" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a file into the folder whose label equals its concern tag.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-move-to-the-matching-concern-folder", "title": "Move to the Matching Concern Folder" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Keeping a file whose primary responsibility is two concerns, forcing an arbitrary tag instead of surfacing the split the ambiguity reports.", "term": "Definition", "wide": true }, { "description": "[One Concern Per File](/records/architecture/one-concern-per-file), [Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Referenced by" }, { "description": "[Sentence-Shaped Name](/records/lexicon/sentence-shaped-name): A multi-role file keeps two concerns under one arbitrary tag, while a sentence-shaped name dodges the tag with a phrase.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[One Concern Per File](/records/architecture/one-concern-per-file), [Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-multi-role-file", "title": "Multi-Role File" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for having a vocabulary refusal name the declared word that covers the refused one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-name-the-covering-concern-in-the-refusal", "title": "Name the Covering Concern in the Refusal" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a closed vocabulary limits how precisely the developer can name a file that its declared words do not yet cover.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with closed-vocabulary", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-naming-expressiveness", "title": "Naming Expressiveness" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Admitting a word naming what the system does rather than what it has, so the vocabulary accumulates activities that classify nothing.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Referenced by" }, { "description": "[Adjective Slot Word](/records/lexicon/adjective-slot-word): A nominalized process word names an activity, while an adjective names a quality.", "term": "Distinct from" }, { "description": "[Instance Identifier Word](/records/lexicon/instance-identifier-word): A nominalized process word names what the system does, while an instance identifier names one registered entry.", "term": "Distinct from" }, { "description": "[Measurement Word](/records/lexicon/measurement-word): A nominalized process word names an activity, while a measurement word names a quantity.", "term": "Distinct from" }, { "description": "[Plural Subject](/records/lexicon/plural-subject): A nominalized process word is an activity in a noun's clothing, while a plural subject is a real noun in the wrong number.", "term": "Distinct from" }, { "description": "[Saturated Role Tag](/records/lexicon/saturated-role-tag): A nominalized process word names an activity, while a saturated role tag names a stature that fits every role.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-nominalized-process-word", "title": "Nominalized Process Word" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Encoding a file's place in a sequence as a numeric prefix, so inserting one step renames every file after it and the grammar must parse a number it cannot classify.", "term": "Definition", "wide": true }, { "description": "[Registry-Held Order](/records/architecture/registry-held-order)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Registry-Held Order](/records/architecture/registry-held-order)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-numeric-order-prefix", "title": "Numeric Order Prefix" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that each folder depth consume a role strictly later than the depth before it, so container, subject and concern may be skipped but never repeated and never revisited.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ordered-role-sequence", "title": "Ordered Role Sequence" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which each check keeps its own exemption list for the same upstream tree.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-per-check-exemption-list", "title": "Per-Check Exemption List" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a separate vocabulary is declared for each language instead of one set of slots read through each language's case.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-per-language-vocabulary", "title": "Per-Language Vocabulary" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a folder under the container that already groups its kind of content.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-place-the-folder-in-an-existing-container", "title": "Place the Folder in an Existing Container" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a file's correct location is derivable from its role alone, with exactly one legal answer.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Narrowest Concern](/records/architecture/narrowest-concern), [Layer Spine Precedence](/records/architecture/layer-spine-precedence), [Derived Naming Registry](/records/architecture/derived-naming-registry), [Collision Consolidation](/records/architecture/collision-consolidation), [Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject), [Conformance at Creation](/records/architecture/conformance-at-creation), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Narrowest Concern](/records/architecture/narrowest-concern), [Layer Spine Precedence](/records/architecture/layer-spine-precedence), [Derived Naming Registry](/records/architecture/derived-naming-registry), [Collision Consolidation](/records/architecture/collision-consolidation), [Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject), [Conformance at Creation](/records/architecture/conformance-at-creation), [Root Spine Files](/records/architecture/root-spine-files)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-placement-predictability", "title": "Placement Predictability" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Using a plural noun such as stats or fields as a subject, where a subject names one thing the system has.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Referenced by" }, { "description": "[Instance Identifier Word](/records/lexicon/instance-identifier-word): A plural subject is a kind named in the plural, while an instance identifier names one entry rather than a kind.", "term": "Distinct from" }, { "description": "[Measurement Word](/records/lexicon/measurement-word): A plural subject names things the system has, while a measurement word names a quantity a file holds.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-plural-subject", "title": "Plural Subject" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a vocabulary is kept in prose the gate cannot read.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-prose-only-vocabulary", "title": "Prose-Only Vocabulary" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a file is written under a provisional name and its correct name is left for a later sweep.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Conformance at Creation](/records/architecture/conformance-at-creation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-provisional-name", "title": "Provisional Name" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A rule or precondition that only a bounded run of conversion records may cite one alignment entry, so a long conversion re-reads its protocol before the rules it applies fade from working context.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-re-alignment-cadence", "title": "Re-Alignment Cadence" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for updating every shape-discovered surface whose pattern encoded a renamed form.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-re-point-the-pattern", "title": "Re-Point the Pattern" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Writing the rules about a declaration into the declaration file itself, producing a document in a schema's format that no code reads.", "term": "Definition", "wide": true }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reasoning-in-the-registry", "title": "Reasoning in the Registry" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for reading a file again and giving it the concern tag its code supports.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reclassify-the-file", "title": "Reclassify the File" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for moving a file from a broad concern tag to the narrowest tag that still fits it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reclassify-to-the-narrower-role", "title": "Reclassify to the Narrower Role" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of each near-miss word already considered and refused, recording the meta concern that covers it so the same word is not proposed twice.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" }, { "description": "[Covering Concern](/records/lexicon/covering-concern): The rejection table lists refused words, while the covering concern is the declared word each refusal points to.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rejection-table", "title": "Rejection Table" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deleting vocabulary entries that copy words another source already owns.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remove-the-copies", "title": "Remove the Copies" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for deleting an ignore entry that hid authored source and fixing the finding it silenced.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-remove-the-ignore-entry", "title": "Remove the Ignore Entry" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing an undeclared word in a name with the declared word that covers its role.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rename-to-a-declared-word", "title": "Rename to a Declared Word" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for renaming a dialect file so its case splitter yields the three declared slots.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-rename-to-the-case-s-word-run", "title": "Rename to the Case's Word Run" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for checking a slot word against the source that allocates it instead of against a copied vocabulary.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-resolve-the-slot-against-its-source", "title": "Resolve the Slot Against Its Source" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Naming a file with the subject its folder already declares, so the member repeats the set and the name carries no information.", "term": "Definition", "wide": true }, { "description": "[Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-restated-set-member", "title": "Restated Set Member" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for ending a filename with its concern tag again, so a glob on the tag finds it.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-restore-the-terminating-tag", "title": "Restore the Terminating Tag" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "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.", "term": "Definition", "wide": true }, { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reverse-coverage-resolution", "title": "Reverse Coverage Resolution" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Classifying a file under a label that names a stature or fits every role, such as util or helper, so it attaches to lifecycle owners, caches, registries and coordinators alike and excludes nothing.", "term": "Definition", "wide": true }, { "description": "Catch-All Tag", "term": "Aliases" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Referenced by" }, { "description": "[Handler as a Tag](/records/lexicon/handler-as-a-tag): A saturated role tag is the class of labels that fit every role, while handler as a tag is one refused word of that class with its covering tags.", "term": "Distinct from" }, { "description": "[Manager as a Tag](/records/lexicon/manager-as-a-tag): A saturated role tag is the class, while manager as a tag is one refused word of it with its covering tags.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Narrowest Concern](/records/architecture/narrowest-concern), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-saturated-role-tag", "title": "Saturated Role Tag" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Naming a file after an activity or a sentence because its role would not resolve, when the name's resistance shows that the file needs a split, a move or a merge.", "term": "Definition", "wide": true }, { "description": "[One Concern Per File](/records/architecture/one-concern-per-file)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[One Concern Per File](/records/architecture/one-concern-per-file)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-sentence-shaped-name", "title": "Sentence-Shaped Name" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that collects its members by matching a pattern rather than by literal path, so a rename silently changes what it collects.", "term": "Definition", "wide": true }, { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree), [Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shape-discovered-surface", "title": "Shape-Discovered Surface" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which jurisdiction is inferred from folder shape instead of declared.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shape-inferred-jurisdiction", "title": "Shape-Inferred Jurisdiction" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which one test file covers several subjects.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-subject-test", "title": "Shared-Subject Test" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a concern with one instance per file, pairing a plural folder label with a singular file tag.", "term": "Definition", "wide": true }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-single-unit-concern", "title": "Single-Unit Concern" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which the layer spine is read as a dependency-direction rule rather than a classification tie-break.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Layer Spine Precedence](/records/architecture/layer-spine-precedence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-spine-read-as-a-dependency-rule", "title": "Spine Read as a Dependency Rule" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a file that holds two concerns into one file per concern.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[One Concern Per File](/records/architecture/one-concern-per-file)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-by-responsibility", "title": "Split by Responsibility" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for dividing a test that covers several subjects into one test file per subject.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-one-test-per-subject", "title": "Split One Test per Subject" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for separating a word that fused a subject and a concern into its two slots.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-split-the-compound", "title": "Split the Compound" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Leaving a test where its subject used to sit after the subject moves or splits, so the test tree no longer shows which tests cover which file.", "term": "Definition", "wide": true }, { "description": "[Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Mirrored Test Placement](/records/architecture/mirrored-test-placement)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-stranded-test", "title": "Stranded Test" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Descriptive data about the files that carry their own resolution contract, such as an aggregator collected by shape, a build entry named in an entry map, and a generated file rewritten on every run.", "term": "Definition", "wide": true }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-structurally-exempt-file", "title": "Structurally Exempt File" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that separates two sets of one concern under a container, present if and only if the sets must not merge.", "term": "Definition", "wide": true }, { "description": "[Sideways Overflow](/records/architecture/sideways-overflow), [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sideways Overflow](/records/architecture/sideways-overflow), [Set-Relative Member Name](/records/architecture/set-relative-member-name)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subject-folder", "title": "Subject Folder" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that names who or what a file serves, occupying the first dot-segment of the filename.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-subject-slot", "title": "Subject Slot" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a file's concern tag differs from the label of its parent folder.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tag-folder-mismatch", "title": "Tag-Folder Mismatch" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing the generic subject with the domain noun the file's source names.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Sanctioned Generic Subject](/records/architecture/sanctioned-generic-subject)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-take-the-domain-noun-as-the-subject", "title": "Take the Domain Noun as the Subject" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for resolving a name collision with a declared variant instead of a new folder level.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth), [Sideways Overflow](/records/architecture/sideways-overflow)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-take-the-variant-slot", "title": "Take the Variant Slot" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a small module can stay in few files and folders rather than expanding into one concern folder per role.", "term": "Definition", "wide": true }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with bounded-nesting-depth", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-tree-compactness", "title": "Tree Compactness" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for writing a discovery pattern that matches a concern at any depth instead of at one.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unanchor-the-pattern", "title": "Unanchor the Pattern" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Reporting an undeclared word without naming the declared word that covers it, so the developer's or the model's next attempt is another guess and the closed set reads as an obstacle rather than a map.", "term": "Definition", "wide": true }, { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" }, { "description": "[Borrowed Synonymy](/records/lexicon/borrowed-synonymy): An unguided refusal names no covering word, while borrowed synonymy judges overlap from everyday senses instead of roles.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unguided-refusal", "title": "Unguided Refusal" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The activity of deciding, for each export nothing imports, whether a call site should use it, whether it is capability waiting for a consumer, whether it is superseded, or whether it went with a merged duplicate.", "term": "Definition", "wide": true }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-unreferenced-export-triage", "title": "Unreferenced Export Triage" }, { "blocks": [ { "items": [ "Kind: [mechanism](/records/kind/mechanism)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A facility that narrows a subject to one facet, occupying the segment between subject and concern and present only on collision or facet ambiguity.", "term": "Definition", "wide": true }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Sideways Overflow](/records/architecture/sideways-overflow), [Collision Consolidation](/records/architecture/collision-consolidation), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" }, { "description": "[Externally Resolved Slot](/records/architecture/externally-resolved-slot): The variant slot is a position in the filename, while an externally resolved slot is a way of resolving a slot's words against their owning source.", "term": "Distinct from" }, { "description": "[Subject Folder](/records/lexicon/subject-folder): The variant slot relieves a collision inside the filename, while a subject folder relieves breadth with a sibling folder.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution), [Sideways Overflow](/records/architecture/sideways-overflow), [Collision Consolidation](/records/architecture/collision-consolidation), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-variant-slot", "title": "Variant Slot" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Resolving a naming collision by giving the second file a variant, so two files doing one job keep two names and the duplication becomes permanent.", "term": "Definition", "wide": true }, { "description": "[Collision Consolidation](/records/architecture/collision-consolidation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Collision Consolidation](/records/architecture/collision-consolidation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-variant-masked-duplicate", "title": "Variant-Masked Duplicate" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A technique for comparing what each aggregator collects before and after a rename, treating a drop to zero as a failure.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-verify-the-collected-count", "title": "Verify the Collected Count" }, { "blocks": [ { "items": [ "Kind: [activity](/records/kind/activity)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "The act of reasoning a proposed word against the declared categories and admitting it only by developer-approved registry edit.", "term": "Definition", "wide": true }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Guided Vocabulary Refusal](/records/architecture/guided-vocabulary-refusal)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vocabulary-admission", "title": "Vocabulary Admission" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "Admitting a word whose role a declared word already covers, such as a synonym or an abbreviation of it, so one role gets two words and classification gets two right answers.", "term": "Definition", "wide": true }, { "description": "Overlapping Word", "term": "Aliases" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Referenced by" }, { "description": "[Index as a Tag](/records/lexicon/index-as-a-tag): Vocabulary inflation is the class of admitting an overlapping word, while index as a tag is one refused word of it.", "term": "Distinct from" }, { "description": "[Adjective Slot Word](/records/lexicon/adjective-slot-word): Vocabulary inflation admits a word whose role is already covered, while an adjective slot word admits a word that names no role.", "term": "Distinct from" }, { "description": "[Duplicated Authority](/records/lexicon/duplicated-authority): Vocabulary inflation is two words for one role, while duplicated authority is two owners for one fact.", "term": "Distinct from" }, { "description": "[Instance Identifier Word](/records/lexicon/instance-identifier-word): Vocabulary inflation adds a second word for a kind, while an instance identifier adds an entry instead of a kind.", "term": "Distinct from" }, { "description": "[Measurement Word](/records/lexicon/measurement-word): Vocabulary inflation adds a synonym of a role, while a measurement word adds a quantity.", "term": "Distinct from" }, { "description": "[Nominalized Process Word](/records/lexicon/nominalized-process-word): Vocabulary inflation adds a synonym of a declared role, while a nominalized process word adds an activity.", "term": "Distinct from" }, { "description": "[Plural Subject](/records/lexicon/plural-subject): Vocabulary inflation adds a synonym, while a plural subject uses a real noun in the wrong number.", "term": "Distinct from" }, { "description": "[Saturated Role Tag](/records/lexicon/saturated-role-tag): Vocabulary inflation adds a second word for one role, while a saturated role tag uses one word for every role.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary), [Agnostic-First Vocabulary](/records/architecture/agnostic-first-vocabulary), [Externally Resolved Slot](/records/architecture/externally-resolved-slot)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vocabulary-inflation", "title": "Vocabulary Inflation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A defect in which a word is read by the vocabulary that declares it rather than by the slot it lands in.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-vocabulary-bound-reading", "title": "Vocabulary-Bound Reading" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Taxonomy / Classification / Naming](/records/lexicon-category/taxonomy-classification-naming)", "Layer: [Structural Core](/records/layer/structural-core)" ], "kind": "list" }, { "entries": [ { "description": "A formal definition of a naming case by where one word ends and the next begins, whether at a capital letter as in camel and pascal case or at a joiner as in snake and kebab case.", "term": "Definition", "wide": true }, { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-word-boundary-case", "title": "Word-Boundary Case" } ], "title": "Taxonomy / Classification / Naming" }, { "icon": "bi-book", "id": "lexicon-category-transactions-state-concurrency", "intro": "Every term in this category is listed as one record, with its kind, its definition and its aliases, the principles whose relations name it, the principle or contract that carries the same name where one exists, and the layer its category belongs to. A tag category also gives each term an example, which is the file the tag places or the rename from a refused word onto a covering tag.", "subsections": [ { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Ordering lock acquisition by hand-reasoning rather than a proven scheme, inviting deadlock.", "term": "Definition", "wide": true }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-ad-hoc-lock-ordering", "title": "Ad-Hoc Lock Ordering" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to apply a set of changes so that either all of them take effect or none do.", "term": "Definition", "wide": true }, { "description": "[Atomicity](/records/architecture/atomicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Atomicity](/records/architecture/atomicity)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-all-or-nothing-state-change", "title": "All-or-Nothing State Change" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for coordinating concurrent writers with locks, versions or ownership, so no write is lost.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state), [Happens-Before Relationship](/records/architecture/happens-before-relationship), [Concurrency](/records/architecture/concurrency), [Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-apply-concurrency-control", "title": "Apply Concurrency Control" }, { "blocks": [ { "items": [ "Kind: [model](/records/kind/model)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A consistency model favoring availability and soft state, letting replicas converge over time rather than staying strongly consistent.", "term": "Definition", "wide": true }, { "description": "[ACID](/records/architecture/acid)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with acid", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-base-eventual-consistency", "title": "BASE/Eventual Consistency" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Writing over another actor's update without checking whether the data changed first, silently losing it.", "term": "Definition", "wide": true }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Optimistic Locking](/records/architecture/optimistic-locking), [Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-blind-overwrite", "title": "Blind Overwrite" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which concurrent flows produce correct results free of races and lost updates, for example because each unit's state is isolated.", "term": "Definition", "wide": true }, { "description": "Concurrency Safety", "term": "Aliases" }, { "description": "[Concurrency Correctness](/records/algorithms/concurrency-correctness)", "term": "Contract" }, { "description": "[State Isolation](/records/architecture/state-isolation), [Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" }, { "description": "[Deadlock Freedom](/records/lexicon/deadlock-freedom): Concurrency correctness is concurrent flows producing correct results, while deadlock freedom is those flows never halting for good.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[State Isolation](/records/architecture/state-isolation), [Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concurrency-correctness", "title": "Concurrency Correctness" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to model concurrent token flow explicitly so its behavior can be analyzed.", "term": "Definition", "wide": true }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" }, { "description": "[Reachability and Deadlock Analysis](/records/lexicon/reachability-and-deadlock-analysis): Concurrent-flow modeling builds the explicit model of token flow, while reachability analysis examines which states that model can reach.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-concurrent-flow-modeling", "title": "Concurrent-Flow Modeling" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to detect that data changed since it was read, so a conflicting write can be rejected.", "term": "Definition", "wide": true }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-conflict-detection", "title": "Conflict Detection" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for stating which reads may be stale, for how long, and how a client learns that its write is visible.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Read-Your-Writes Violation](/records/architecture/read-your-writes-violation), [Replication](/records/architecture/replication)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-contract", "title": "Consistency Contract" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that the invariants a transaction must preserve be defined for its scope.", "term": "Definition", "wide": true }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-consistency-rules", "title": "Consistency Rules" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to commit a set of related changes together as one atomic unit of work.", "term": "Definition", "wide": true }, { "description": "[Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-coordinated-persistence", "title": "Coordinated Persistence" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which strictly isolating state limits components from directly sharing data.", "term": "Definition", "wide": true }, { "description": "[State Isolation](/records/architecture/state-isolation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with state-isolation", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-data-sharing", "title": "Data Sharing" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a concurrent design is provably free of states where progress halts permanently, which acquiring several locks pessimistically puts at risk.", "term": "Definition", "wide": true }, { "description": "Deadlocks", "term": "Aliases" }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking), [Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" }, { "description": "[Lock-Free Throughput](/records/lexicon/lock-free-throughput): Deadlock freedom is never halting for good, while lock-free throughput is sustaining speed by not holding locks at all.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pessimistic-locking, [Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-deadlock-freedom", "title": "Deadlock Freedom" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Reading or overwriting another transaction's uncommitted changes, so a rollback leaves corrupt data.", "term": "Definition", "wide": true }, { "description": "[Isolation](/records/architecture/isolation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Isolation](/records/architecture/isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-dirty-reads-writes", "title": "Dirty Reads/Writes" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which insisting on strong transactional consistency reduces availability across a distributed system.", "term": "Definition", "wide": true }, { "description": "[ACID](/records/architecture/acid)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with acid", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-availability", "title": "Distributed Availability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which enforcing atomic transactions across nodes limits how far a system can scale out.", "term": "Definition", "wide": true }, { "description": "[Atomicity](/records/architecture/atomicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with atomicity", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-distributed-scalability", "title": "Distributed Scalability" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which committed data survives crashes and is never lost once acknowledged.", "term": "Definition", "wide": true }, { "description": "[ACID](/records/architecture/acid)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[ACID](/records/architecture/acid)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-durability", "title": "Durability" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that side effects be confined to explicit boundaries rather than scattered through pure logic.", "term": "Definition", "wide": true }, { "description": "[Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-effect-boundaries", "title": "Effect Boundaries" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for removing a race by ordering, locking or making the shared state immutable, instead of retrying the test.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-fix-the-race", "title": "Fix the Race" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A transaction that silently spans service boundaries, coupling systems that should commit independently.", "term": "Definition", "wide": true }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Saga Pattern](/records/architecture/saga-pattern), [Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-hidden-distributed-transaction", "title": "Hidden Distributed Transaction" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that an operation carry a deduplication key or be deterministic so repeating it is safe.", "term": "Definition", "wide": true }, { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-idempotency-key-or-deterministic-operation", "title": "Idempotency Key or Deterministic Operation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Replicas or models that disagree on the same data, so reads return conflicting answers.", "term": "Definition", "wide": true }, { "description": "[Consistency](/records/architecture/consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-inconsistent-replicas-models", "title": "Inconsistent Replicas/Models" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring which writes commit or fail together.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state), [Atomicity](/records/architecture/atomicity), [ACID](/records/architecture/acid), [Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-introduce-transaction-boundary", "title": "Introduce Transaction Boundary" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which widening a transaction to cover more work increases contention and failure surface.", "term": "Definition", "wide": true }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with transaction-boundary", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-large-transaction-scope", "title": "Large Transaction Scope" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a lock be exclusively held by one actor for the duration of a critical section.", "term": "Definition", "wide": true }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lock-ownership", "title": "Lock Ownership" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which a design sustains high throughput by coordinating concurrent access without holding locks.", "term": "Definition", "wide": true }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with pessimistic-locking", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-lock-free-throughput", "title": "Lock-Free Throughput" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for replacing in-place mutation with new values, so state shared between readers cannot change under them.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Shared Mutable State](/records/architecture/shared-mutable-state), [Immutability](/records/architecture/immutability), [Concurrency](/records/architecture/concurrency), [Concurrency Control](/records/architecture/concurrency-control), [State Isolation](/records/architecture/state-isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-make-immutable", "title": "Make Immutable" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for declaring how two concurrent changes to one value are combined.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lost Update](/records/architecture/lost-update)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-merge-policy", "title": "Merge Policy" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which formally modeling concurrency as a net adds effort over writing the code directly.", "term": "Definition", "wide": true }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with petri-nets", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-modeling-overhead", "title": "Modeling Overhead" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Side effects whose repetition changes the outcome, so retrying an operation double-applies them.", "term": "Definition", "wide": true }, { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-non-repeatable-side-effects", "title": "Non-Repeatable Side Effects" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Committing only some of a multi-step change after a failure, leaving state half-updated and inconsistent.", "term": "Definition", "wide": true }, { "description": "[Atomicity](/records/architecture/atomicity)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Atomicity](/records/architecture/atomicity), [ACID](/records/architecture/acid)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-partial-commit", "title": "Partial Commit" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which pushing side effects to the edges can forgo in-place optimizations that mutate for speed.", "term": "Definition", "wide": true }, { "description": "[Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with controlled-side-effects", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-performance-optimization", "title": "Performance Optimization" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that a modeled system be expressed as places holding tokens and transitions that move them.", "term": "Definition", "wide": true }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-places-and-transitions", "title": "Places and Transitions" }, { "blocks": [ { "items": [ "Kind: [pattern](/records/kind/pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "An arrangement that keeps decision logic pure and pushes all side effects to a thin outer shell.", "term": "Definition", "wide": true }, { "description": "[Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pure Functions](/records/architecture/pure-functions), [Controlled Side Effects](/records/architecture/controlled-side-effects)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-pure-core-imperative-shell", "title": "Pure Core / Imperative Shell" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to analyze which states a concurrent model can reach and whether any of them deadlock.", "term": "Definition", "wide": true }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reachability-and-deadlock-analysis", "title": "Reachability and Deadlock Analysis" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for routing a client's reads to the primary for a short time after it writes, so it sees its own write.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Read-Your-Writes Violation](/records/architecture/read-your-writes-violation), [Causal Consistency](/records/architecture/causal-consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-read-from-primary-after-write", "title": "Read From Primary After Write" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for periodically comparing two copies of related state and repairing the differences found.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Silent Data Corruption](/records/architecture/silent-data-corruption), [Dual Write](/records/architecture/dual-write), [Eventual Consistency](/records/architecture/eventual-consistency), [Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reconciliation-job", "title": "Reconciliation Job" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to trust that stored state always satisfies its invariants.", "term": "Definition", "wide": true }, { "description": "[Consistency](/records/architecture/consistency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Consistency](/records/architecture/consistency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-reliable-state", "title": "Reliable State" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which coordinating saves through a unit of work adds indirection to the persistence layer.", "term": "Definition", "wide": true }, { "description": "[Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with unit-of-work-pattern", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-repository-complexity", "title": "Repository Complexity" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which rejecting conflicting writes pushes retry-and-merge logic onto callers.", "term": "Definition", "wide": true }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with optimistic-locking", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-retry-complexity", "title": "Retry Complexity" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to run concurrent transactions without their intermediate states interfering.", "term": "Definition", "wide": true }, { "description": "[Isolation](/records/architecture/isolation)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Isolation](/records/architecture/isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-concurrent-operations", "title": "Safe Concurrent Operations" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to let multiple actors mutate shared state in parallel without corrupting it.", "term": "Definition", "wide": true }, { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-parallel-mutation", "title": "Safe Parallel Mutation" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to retry an operation without fear of duplicating its effects.", "term": "Definition", "wide": true }, { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-retries", "title": "Safe Retries" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to mutate state within a bounded transaction so partial failures cannot corrupt it.", "term": "Definition", "wide": true }, { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Transaction Boundary](/records/architecture/transaction-boundary)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-safe-state-mutation", "title": "Safe State Mutation" }, { "blocks": [ { "items": [ "Kind: [anti-pattern](/records/kind/anti-pattern)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "Persisting related changes through many independent save calls, so a mid-sequence failure leaves partial state.", "term": "Definition", "wide": true }, { "description": "[Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Unit of Work Pattern](/records/architecture/unit-of-work-pattern)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-scattered-save-calls", "title": "Scattered Save Calls" }, { "blocks": [ { "items": [ "Kind: [constraint](/records/kind/constraint)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The requirement that all state shared between concurrent actors be identified before it is guarded.", "term": "Definition", "wide": true }, { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Concurrency Control](/records/architecture/concurrency-control)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-shared-state-identification", "title": "Shared State Identification" }, { "blocks": [ { "items": [ "Kind: [quality-attribute](/records/kind/quality-attribute)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The degree to which making operations idempotent requires tracking processed keys or prior state.", "term": "Definition", "wide": true }, { "description": "[Idempotency](/records/architecture/idempotency)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the tension resolution with idempotency", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-state-tracking", "title": "State Tracking" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to prevent conflicting updates by locking data before it is modified.", "term": "Definition", "wide": true }, { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Pessimistic Locking](/records/architecture/pessimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-conflict-prevention", "title": "Strong Conflict Prevention" }, { "blocks": [ { "items": [ "Kind: [capability](/records/kind/capability)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "The ability to guarantee that a group of operations is atomic, consistent, isolated, and durable.", "term": "Definition", "wide": true }, { "description": "[ACID](/records/architecture/acid)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[ACID](/records/architecture/acid)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-strong-transactional-guarantees", "title": "Strong Transactional Guarantees" }, { "blocks": [ { "items": [ "Kind: [technique](/records/kind/technique)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A technique for choosing how much concurrent transactions see of each other's uncommitted and recent writes.", "term": "Definition", "wide": true } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Lost Update](/records/architecture/lost-update), [Isolation](/records/architecture/isolation)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-transaction-isolation-level", "title": "Transaction Isolation Level" }, { "blocks": [ { "items": [ "Kind: [artifact](/records/kind/artifact)", "Category: [Transactions / State / Concurrency](/records/lexicon-category/transactions-state-concurrency)", "Layer: [Atomic Boundary](/records/layer/atomic-boundary)" ], "kind": "list" }, { "entries": [ { "description": "A field on a record whose value changes on each write, used to detect concurrent modification.", "term": "Definition", "wide": true }, { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Referenced by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "[Optimistic Locking](/records/architecture/optimistic-locking)", "term": "Checked by" }, { "description": "The term's definition and every architecture edge that names the term", "term": "Population" }, { "description": "A verdict stands until the definition, the term's kind or an edge that names it changes", "term": "Freshness" }, { "description": "The resolution gate fails an edge that resolves to no term, and a definition that opens as another kind", "term": "Refusal" }, { "description": "The resolution validator's pass over every edge target and every definition opening", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a term no edge names, a dangling dependency and a second check home, and the bundled terms pass", "term": "Evidence" }, { "description": "The term record, which every edge that names the term cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "lexicon-version-field", "title": "Version Field" } ], "title": "Transactions / State / Concurrency" } ] }, { "icon": "bi-cpu", "id": "algorithms", "label": "Algorithms", "layout": "ontology", "sections": [ { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_evidence_before_generation[\"Evidence-Before-Generation\"]\n n_semantic_operation_boundary[\"Semantic Operation Boundary\"]\n n_capability_profile[\"Capability Profile\"]\n n_creation_history_collision[\"Creation History Collision\"]\n n_domain_cache_validation[\"Domain Cache Validation\"]\n n_scope_extraction[\"Scope Extraction\"]\n n_non_destructive_domain_investigation[\"Non-Destructive Domain Investigation\"]\n n_domain_knowledge_base[\"Domain Knowledge Base\"]\n n_risk_complexity_reversibility[\"Risk Complexity Reversibility\"]\n n_existing_pattern_extraction[\"Existing Pattern Extraction\"]\n n_knowledge_documentation_relevance[\"Knowledge Documentation Relevance\"]\n n_principle_extraction[\"Principle Extraction\"]\n n_adaptive_phase_boundary[\"Adaptive Phase Boundary\"]\n n_phase_validation_requirement[\"Phase Validation Requirement\"]\n n_portable_contract_composition[\"Portable Contract Composition\"]\n n_validation_strategy_composition[\"Validation Strategy Composition\"]\n n_replacement_safety[\"Replacement Safety\"]\n n_adapter_rendering[\"Adapter Rendering\"]\n n_audit_artifact[\"Audit Artifact\"]\n n_semantic_compliance_validation[\"Semantic Compliance Validation\"]\n n_evidence_grounding_validation[\"Evidence Grounding Validation\"]\n n_algorithmic_embodiment_validation[\"Algorithmic Embodiment Validation\"]\n n_final_generation_report[\"Final Generation Report\"]\n n_agent_generation_completion[\"Agent Generation Completion\"]\n n_agent_creator_kernel[\"Agent Creator Kernel\"]\n n_agent_generation_concern[\"\"]\n n_audit_artifact --> n_capability_profile\n n_agent_creator_kernel --> n_capability_profile\n n_agent_creator_kernel --> n_scope_extraction\n n_agent_creator_kernel --> n_domain_knowledge_base\n n_agent_creator_kernel --> n_principle_extraction\n n_agent_creator_kernel --> n_adapter_rendering\n n_agent_creator_kernel --> n_final_generation_report\n n_agent_creator_kernel --> n_agent_generation_completion\n n_agent_creator_kernel --> n_evidence_before_generation\n n_agent_creator_kernel --> n_risk_complexity_reversibility\n n_agent_creator_kernel --> n_adaptive_phase_boundary\n n_agent_creator_kernel --> n_creation_history_collision\n n_agent_creator_kernel --> n_phase_validation_requirement\n n_agent_creator_kernel --> n_evidence_grounding_validation" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-agent-creation", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Discover available context, inspect target-domain resources, extract concrete facts, construct a knowledge base, and generate only from verified evidence.", "term": "Intent" }, { "description": "Agent generation must be grounded in inspected domain structure, not assumptions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Request → Discover → Inspect → ExtractFacts → KnowledgeBase → Generate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EvidenceBeforeGeneration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nGeneratedAgent ::= \"allowed_only_if_evidence_grounded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent generated from the request text and prior model knowledge, never inspecting the target.", "kind": "code", "language": "text", "title": "Before" }, { "code": "request → discover resources → inspect domain → extract facts → knowledge base → generate only from verified evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-evidence-before-generation", "title": "Evidence-Before-Generation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Define required work as semantic operations, defer runtime execution details to adapters, and reject runtime-specific primitives from the portable core contract.", "term": "Intent" }, { "description": "The core agent contract describes what must happen; the adapter decides how it happens.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticVerb → AdapterMapping → RuntimeAction → Result", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticBoundary ::= \"→\" \"→\" \"→\" \nSemanticOperation ::= \"DECLARE_RESOURCE\" | \"DISCOVER_RESOURCES\" | \"READ_RESOURCE\" | \"SEARCH_CONTENT\" | \"ANALYZE_CONTENT\" | \"EXTRACT_FACTS\" | \"CALCULATE_METRIC\" | \"COMPOSE_ARTIFACT\" | \"VALIDATE_ARTIFACT\" | \"PERSIST_ARTIFACT\" | \"REPORT_RESULT\" | \"REQUEST_DECISION\"\nCoreConstraint ::= \"no_runtime_specific_paths_or_commands\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent core hardcodes a specific search command and an absolute path, so it only runs on one runtime.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic op{DISCOVER/READ/SEARCH/ANALYZE} → adapter maps to the runtime → the core carries no runtime path or command", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-operation-boundary", "title": "Semantic Operation Boundary" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect filesystem, search, execution, persistence, validation, and user-interaction capabilities; mark unsupported capabilities; substitute where safe; block where required capability is non-substitutable.", "term": "Intent" }, { "description": "Generated workflows must know what their runtime can do.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CapabilitySet → Probe → Available|Unavailable|Substituted → RuntimeMode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CapabilityProfile ::= \"→\" \"→\" \nCapabilityVerdict ::= \"full\" | \"degraded\" | \"blocked\"\nCapability ::= \"filesystem\" | \"search\" | \"execution\" | \"persistence\" | \"validation\" | \"user_interaction\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent assumes it can execute and write, then fails when it cannot.", "kind": "code", "language": "text", "title": "Before" }, { "code": "required capabilities{filesystem, search, execution, persistence, validation} → probe each → mode{full | degraded | blocked}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-capability-profile", "title": "Capability Profile" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Load existing agent and invocation registries, map existing identities, compare target name and domain, and require the developer's decision before refinement, renaming, replacement, or cancellation.", "term": "Intent" }, { "description": "Agent creation must not silently duplicate or overwrite prior work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetAgent → ExistingRegistry → NameCollision? → DomainCollision? → Decision", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CreationCollision ::= \"→\" \"→\" \"→\" \nAgentOperationMode ::= \"CREATE\" | \"REFINE\" | \"RENAME\" | \"REPLACE\" | \"CANCEL\"\nCollisionCheck ::= \"name_collision\" | \"domain_collision\" | \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new agent silently overwrites an existing one of the same name.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target name → existing registry → name/domain collision? → developer decision{CREATE|REFINE|RENAME|REPLACE|CANCEL}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-creation-history-collision", "title": "Creation History Collision" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Normalize the domain path, compute a domain hash, search cache entries, fingerprint the domain's sources, and reuse cached knowledge only when the entry's identity matches and its derivation fingerprint equals the current one.", "term": "Intent" }, { "description": "Prior domain intelligence can be reused only when freshness and identity are verified.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainPath → Normalize → Hash → CacheLookup → FingerprintCheck → UseCache|Investigate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainCache ::= \"→\" \"→\" \"→\" \"→\" \nCacheDecision ::= \"use_cached_domain\" | \"reject_stale_cache\" | \"no_cache_investigate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Stale cached domain intelligence reused as if it were current.", "kind": "code", "language": "text", "title": "Before" }, { "code": "domain path → normalize + hash → cache lookup → fingerprint of the domain's sources vs the entry's derivation fingerprint → {use cached | reject stale | investigate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-domain-cache-validation", "title": "Domain Cache Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Determine whether the target is a resource, directory, module, repository, or unknown scope; then extract interfaces, declarations, dependencies, systems, or boundaries appropriate to that scope.", "term": "Intent" }, { "description": "Investigation depth must match target-domain shape.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetPath → InvestigationType → ScopeModel → ResourceSet → InterfaceFacts", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ScopeExtraction ::= \"→\" \"→\" \nInvestigationDepth ::= \"single-resource\" | \"directory\" | \"module\" | \"repository\" | \"auto\"\nDomainScope ::= | | | ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A repository investigated at single-file depth, missing every boundary.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target → investigation depth{single-resource|directory|module|repository} → scope-matched facts{interfaces, deps, boundaries}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-scope-extraction", "title": "Scope Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Prepare static investigation, optionally prepare safe executable analysis, prohibit source mutation, execute or emulate analysis, and merge observable outputs into domain intelligence.", "term": "Intent" }, { "description": "Domain discovery may inspect and analyze, but must not mutate the source domain.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StaticPlan + OptionalExecutablePlan → Analyze → ExtractStructure → CacheResults", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainInvestigation ::= \"→\" \"→\" \nInvestigationPlan ::= \",\" \nExecutionConstraint ::= \"non_destructive\" \",\" \"observable_output_required\" \",\" \"source_mutation_forbidden\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [observability_traceability](/records/force/observability-traceability), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Investigation runs a script that mutates the source it is inspecting.", "kind": "code", "language": "text", "title": "Before" }, { "code": "static plan (+ optional safe executable) → analyze, never mutate the source → observable output → domain knowledge", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-non-destructive-domain-investigation", "title": "Non-Destructive Domain Investigation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Store target scope, discovered structure, purposes, dependencies, interfaces, patterns, statistics, timestamp, and evidence sources in a reusable knowledge object.", "term": "Intent" }, { "description": "Agent generation needs an explicit evidence substrate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainFacts → Statistics → EvidenceSources → KnowledgeBase", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainKnowledgeBase ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nStatistics ::= \"resource_count\" \",\" \"interface_count\" \",\" \"dependency_count\" \",\" \"resource_types\" \",\" \"architectural_patterns\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Generation proceeds with no explicit evidence substrate to cite.", "kind": "code", "language": "text", "title": "Before" }, { "code": "domain facts + structure + purposes + deps + interfaces + patterns + statistics + evidence sources → reusable knowledge base", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-domain-knowledge-base", "title": "Domain Knowledge Base" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Analyze domain dependencies, side effects, resource count, interface count, dependency patterns, and uncertainty factors to assign risk, complexity, reversibility, and uncertainty.", "term": "Intent" }, { "description": "Phase rigor should be proportional to domain risk and complexity.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeBase → RiskFactors → ComplexityScore → Reversibility → Uncertainty", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DomainCharacteristics ::= \",\" \",\" \",\" \nRiskLevel ::= \"low\" | \"medium\" | \"high\"\nReversibility ::= \"reversible\" | \"partially-reversible\" | \"irreversible\"\nUncertaintyLevel ::= \"low\" | \"medium\" | \"high\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent given the same phase count regardless of how risky its domain is.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge base → risk{low|medium|high} + complexity + reversibility{reversible|partial|irreversible} + uncertainty", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-risk-complexity-reversibility", "title": "Risk Complexity Reversibility" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Inspect existing agent specifications, count phase markers, validation gates, and semantic operations, extract reusable structures, and derive baseline design conventions.", "term": "Intent" }, { "description": "New agents should conform to proven local agent grammar where evidence exists.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ExistingSpecs → PhaseCount → GateCount → OperationUsage → ReusablePatterns", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ExistingPatternExtraction ::= \"→\" \"→\" \nStructuralMetricSet ::= \"phase_count\" \",\" \"validation_gate_count\" \",\" \"semantic_operation_count\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new agent invented in a shape that ignores the local agent grammar.", "kind": "code", "language": "text", "title": "Before" }, { "code": "existing specs → count{phases, gates, semantic ops} → reusable structures → baseline conventions", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-existing-pattern-extraction", "title": "Existing Pattern Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Discover knowledge documents, read descriptions, compare them against domain characteristics, score relevance, and exclude irrelevant documents from core reasoning.", "term": "Intent" }, { "description": "Supporting documents should influence generation only when relevant to the target domain.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeDocs → RelevanceAnalysis → RelevantDocs → PrincipleInput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "KnowledgeRelevance ::= \"→\" \"→\" \nRelevanceDecision ::= \"include\" | \"exclude\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every knowledge doc fed into reasoning, relevant or not.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge docs → read descriptions → score relevance vs domain → include relevant, exclude the rest", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-knowledge-documentation-relevance", "title": "Knowledge Documentation Relevance" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Start from structural principles, test applicability against domain characteristics, add domain-specific principles from relevant documents, and exclude runtime-specific principles from the core.", "term": "Intent" }, { "description": "Generated agents should embody portable design principles selected from evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructuralPrinciples + DomainDocs → Applicability → CorePrinciples", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PrincipleExtraction ::= \"→\" \"→\" \nCorePrinciple ::= \"phase_gated_execution\" | \"validation_boundaries\" | \"declaration_before_use\" | \"evidence_before_composition\" | \"adapter_separation\" | \"auditability\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Runtime-specific principles baked into the portable core.", "kind": "code", "language": "text", "title": "Before" }, { "code": "structural candidates + domain docs → test applicability → core principles{phase-gated, validation-boundaries, declaration-before-use, evidence-before-composition, adapter-separation, auditability}; runtime-specific excluded", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-principle-extraction", "title": "Principle Extraction" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select phase count from risk and complexity, assign phase boundaries, and strengthen validation density for high-risk or high-complexity domains.", "term": "Intent" }, { "description": "Agent structure should scale with domain difficulty.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Risk + Complexity + Uncertainty → PhaseCount → PhaseBoundaries", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseBoundarySelection ::= \",\" \",\" \"→\" \nPhaseStructure ::= | | \nThreePhase ::= \"Discovery\" \",\" \"Generation\" \",\" \"Verification\"\nFivePhase ::= \"Discovery\" \",\" \"Analysis\" \",\" \"Generation\" \",\" \"Verification\" \",\" \"Finalization\"\nSevenPhase ::= \"Discovery\" \",\" \"Analysis\" \",\" \"Planning\" \",\" \"Validation\" \",\" \"Generation\" \",\" \"Verification\" \",\" \"Finalization\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [performance_scaling](/records/force/performance-scaling), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A high-risk irreversible domain given a 3-phase agent.", "kind": "code", "language": "text", "title": "Before" }, { "code": "risk + complexity + uncertainty → phase count{3 | 5 | 7} → validation density proportional to difficulty", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-adaptive-phase-boundary", "title": "Adaptive Phase Boundary" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For every phase boundary, generate explicit validation requirements from the phase purpose, adapter-separation needs, evidence-grounding needs, and safety constraints.", "term": "Intent" }, { "description": "Every phase must end with verifiable exit conditions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PhaseSet → RequirementDerivation → ValidationGateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseValidation ::= \"→\" \"→\" \nPhaseValidationGate ::= \":\" \nRequirementSet ::= | \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A phase ends with no verifiable exit condition.", "kind": "code", "language": "text", "title": "Before" }, { "code": "phase → derive requirements{purpose, adapter-separation, evidence-grounding, safety} → a validation gate per phase", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-validation-requirement", "title": "Phase Validation Requirement" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose identity, purpose, methodology, domain scope, characteristics, capabilities, phases, validation strategy, constraints, and required outputs into a runtime-neutral agent contract.", "term": "Intent" }, { "description": "The portable contract is the canonical artifact; adapter outputs are renderings.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnowledgeBase + Principles + Phases → PortableContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PortableAgentContract ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nOutputContract ::= \"portable_agent_contract\" | \"invocation_contract\" | \"audit_report\" | \"final_report\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent authored directly as a runtime artifact, welded to one runtime.", "kind": "code", "language": "text", "title": "Before" }, { "code": "knowledge base + principles + phases → runtime-neutral contract{identity, purpose, domain model, capabilities, phase specs, validation strategy, constraints, outputs} = the canonical artifact", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-portable-contract-composition", "title": "Portable Contract Composition" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Define pre-generation, during-generation, and post-generation checks that enforce capabilities, creation history, evidence grounding, adapter separation, schema validity, and absence of unsupported assumptions.", "term": "Intent" }, { "description": "Generated artifacts must be validated throughout composition, not only afterward.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreChecks → DuringChecks → PostChecks → ValidationStrategy", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GenerationValidationStrategy ::= \",\" \",\" \nPreGenerationChecks ::= \"capabilities_detected\" \",\" \"history_checked\" \",\" \"domain_knowledge_available\"\nDuringGenerationChecks ::= \"phase_gates_enforced\" \",\" \"evidence_grounded_content\" \",\" \"adapter_separated\"\nPostGenerationChecks ::= \"schema_valid\" \",\" \"audit_complete\" \",\" \"unsupported_assumptions_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The artifact validated only after it is written, never during.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre{capabilities detected, history checked, knowledge available} + during{phase gates, evidence-grounded, adapter-separated} + post{schema valid, audit complete, no unsupported assumptions}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-validation-strategy-composition", "title": "Validation Strategy Composition" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "If replacing an existing artifact, require prior approval, archive existing artifacts, verify archive persistence, and block new persistence if archival cannot be confirmed.", "term": "Intent" }, { "description": "Destructive generation requires recoverability before mutation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ReplaceIntent → Approval → ArchiveExisting → VerifyArchive → Persist|Block", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReplacementSafety ::= \"→\" \"→\" \"→\" \nArchivePolicy ::= \"archive_required_if_replace\" | \"archive_not_required\"\nPersistenceDecision ::= \"safe_to_persist\" | \"blocked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An existing agent overwritten with no archive — the original is lost.", "kind": "code", "language": "text", "title": "Before" }, { "code": "REPLACE → require approval → archive existing → verify the archive → persist only if recoverable, else block", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-replacement-safety", "title": "Replacement Safety" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Render the portable contract into runtime-specific agent specification, invocation contract, and audit artifacts only through adapter-defined schemas and destinations.", "term": "Intent" }, { "description": "Runtime-specific artifacts are projections of the portable contract, not replacements for it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PortableContract → AdapterSchema → RenderedArtifact → Validate → Persist", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AdapterRendering ::= \"→\" \"→\" \"→\" \"→\" \nArtifactSet ::= \"agent_specification\" \",\" \"invocation_contract\" \",\" \"audit_report\"\nAdapterConstraint ::= \"adapter_may_add_metadata_but_not_alter_core_intent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The runtime artifact edited directly, diverging from the portable contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "portable contract → adapter schema → artifacts{agent spec, invocation contract, audit} → adapter may add metadata, never alter core intent", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-adapter-rendering", "title": "Adapter Rendering" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Record agent name, domain, operation mode, runtime environment, risk, complexity, reversibility, uncertainty, phase count, validation gates, evidence sources, capability profile, adapter identity, portability status, and timestamp.", "term": "Intent" }, { "description": "Generated agents require an inspectable provenance trail.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GenerationState → AuditFields → AuditReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AuditReport ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capability Profile](/records/algorithms/capability-profile)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A generated agent with no provenance — no record of how or from what it was built.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generation state → audit{identity, domain, mode, risk metrics, gates, evidence sources, capability profile, adapter identity, portability status}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "[Capability Profile](/records/algorithms/capability-profile)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-audit-artifact", "title": "Audit Artifact" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Re-read the persisted agent specification, search for semantic operations, phase markers, validation gates, and runtime-specific leakage, then mark compliant only when required counts pass and leakage is absent.", "term": "Intent" }, { "description": "Persistence is not enough; the stored artifact must still satisfy semantic structure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PersistedSpec → MarkerSearch → CountMetrics → LeakageCheck → ComplianceVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticCompliance ::= \"→\" \"→\" \"→\" \"→\" \nComplianceVerdict ::= \"compliant\" | \"non_compliant\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The in-memory plan judged compliant, but the stored artifact never re-checked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "re-read persisted spec → search{semantic ops, phase markers, gates} + leakage check → compliant only if counts pass and zero runtime leakage", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-compliance-validation", "title": "Semantic Compliance Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Search generated output for unsupported claims and evidence references, compare generated claims against the knowledge base, calculate grounding score, and reject artifacts below threshold.", "term": "Intent" }, { "description": "Generated architecture claims must trace back to evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedSpec → UnsupportedClaimSearch → EvidenceReferenceCheck → GroundingScore → Accept|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EvidenceGrounding ::= \"→\" \"→\" \"→\" \nGroundingVerdict ::= \"grounded\" | \"unsupported_claims_present\" | \"insufficient_evidence_references\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The generated agent asserts architecture claims that trace to nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated spec → find claims → compare against the knowledge base → grounding score → reject below threshold", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-evidence-grounding-validation", "title": "Evidence Grounding Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Verify that generated agents contain phase gates, declaration-before-use structure, calculated metrics, exact thresholds or comparisons, and iterative discovery patterns.", "term": "Intent" }, { "description": "The generated agent must embody the intended reasoning architecture, not merely describe it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedSpec → EmbodimentMarkers → Score → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AlgorithmicEmbodiment ::= \"→\" \"→\" \"→\" \nEmbodimentMarkerSet ::= \"phase_gates\" \",\" \"declaration_before_use\" \",\" \"calculated_metrics\" \",\" \"thresholds\" \",\" \"iterative_discovery\"\nEmbodimentVerdict ::= \"embodied\" | \"insufficiently_embodied\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The agent describes phase gates in prose but does not embody them.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated spec → markers{phase gates, declaration-before-use, calculated metrics, thresholds, iterative discovery} → embodied | insufficiently-embodied", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-algorithmic-embodiment-validation", "title": "Algorithmic Embodiment Validation" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Summarize generated agent, target domain, operation mode, adapter, risk, complexity, reversibility, uncertainty, phase count, validation-gate count, compliance results, artifact references, degraded mode, and unsupported capabilities.", "term": "Intent" }, { "description": "The final report must distinguish generated artifacts, validation status, and limitations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationResults + ArtifactRefs + Limitations → FinalReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FinalGenerationReport ::= \",\" \",\" \",\" \",\" \nComplianceSummary ::= \"semantic_operations\" \",\" \"adapter\" \",\" \"evidence_grounding\" \",\" \"algorithmic_embodiment\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A report that conflates the artifact, its validation status, and its limitations.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validation results + artifact refs + limitations{degraded mode, unsupported capabilities} → report distinguishing all three", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-final-generation-report", "title": "Final Generation Report" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Accept the generated agent as complete only when semantic-compliance, evidence-grounding above threshold, and algorithmic-embodiment all pass and the audit trail is recorded; otherwise route to regeneration or a blocked report.", "term": "Intent" }, { "description": "Agent generation terminates as accepted only on a full validation pass — never a claim while any compliance, grounding, or embodiment gate is unmet.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationVerdicts → AuditPresence → Accept|Regenerate|Blocked", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentGenerationCompletion ::= \"→\" \"→\" \nAcceptanceVerdict ::= \"agent_accepted\" | \"regenerate_required\" | \"blocked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Composed by" }, { "description": "[Agent Creator Kernel](/records/algorithms/agent-creator-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A generated agent declared ready while its evidence-grounding failed and its algorithmic embodiment was insufficient.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic compliance passed + evidence grounded above threshold + algorithmically embodied + audit recorded → agent_accepted; else regenerate | blocked", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-generation-completion", "title": "Agent Generation Completion" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Load configuration, detect capabilities, check creation history, validate cache, discover domain evidence, build knowledge base, analyze characteristics, extract principles, define phases, compose portable contract, render adapter artifacts, validate outputs, audit, and report.", "term": "Intent" }, { "description": "Agent creation is an evidence-gated compiler from target-domain structure into portable agent contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Config → Capabilities → History → Cache → Discovery → Knowledge → Analysis → Principles → Phases → Contract → AdapterRender → Validate → Audit → Report", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentCreatorKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Principle Extraction](/records/algorithms/principle-extraction), [Adapter Rendering](/records/algorithms/adapter-rendering), [Final Generation Report](/records/algorithms/final-generation-report), [Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[Ungrounded Content](/records/architecture/ungrounded-content)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation)", "term": "orient" }, { "description": "[Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility)", "term": "see" }, { "description": "[Principle Extraction](/records/algorithms/principle-extraction)", "term": "derive" }, { "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary)", "term": "intent" }, { "description": "[Creation History Collision](/records/algorithms/creation-history-collision)", "term": "constrain" }, { "description": "[Phase Validation Requirement](/records/algorithms/phase-validation-requirement)", "term": "project" }, { "description": "[Adapter Rendering](/records/algorithms/adapter-rendering)", "term": "act" }, { "description": "[Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation)", "term": "verify" }, { "description": "[Final Generation Report](/records/algorithms/final-generation-report)", "term": "commit" }, { "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A target domain turned straight into an agent by assumption, ungated.", "kind": "code", "language": "text", "title": "Before" }, { "code": "config → capabilities → history → cache → discover evidence → knowledge → risk analysis → principles → phases → portable contract → adapter render → validate{semantic/grounding/embodiment} → audit → report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "[Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Principle Extraction](/records/algorithms/principle-extraction), [Adapter Rendering](/records/algorithms/adapter-rendering), [Final Generation Report](/records/algorithms/final-generation-report), [Agent Generation Completion](/records/algorithms/agent-generation-completion)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-creator-kernel", "title": "Agent Creator Kernel" }, { "blocks": [ { "items": [ "Domain: [agent-creation](/records/algorithms-domain/agent-creation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → → → ", "term": "Intent" }, { "description": "Any generated agent should be treated as a compiled artifact whose source is inspected domain evidence and whose target is a portable, adapter-renderable contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Context → Capability → History → Evidence → Knowledge → Risk → Phases → Contract → Adapter → Validation → Audit → Report", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentGenerationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nValidationSet ::= \"semantic_compliance\" \",\" \"adapter_compliance\" \",\" \"evidence_grounding\" \",\" \"algorithmic_embodiment\" \",\" \"runtime_specific_leakage_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the agent auditor, which walks a generated agent against the agent-quality dimensions, the structured-document validator, which holds every agent to the grammar's node form", "term": "Checked by" }, { "description": "Every agent the creator generates, and the domain evidence each one cites", "term": "Population" }, { "description": "A verdict stands until the agent, its evidence or the grammar changes", "term": "Freshness" }, { "description": "The validator fails an agent with a malformed node or gate, and the creator persists no agent that fails its grounding or embodiment check", "term": "Refusal" }, { "description": "None, because an agent contract is text; its runs are observed by the checks it declares", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real agent document and validates every agent on disk clean, while the auditor's walk is stated as a class", "term": "Evidence" }, { "description": "The grammar and the agent-quality dimensions, which every generated agent conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-generation-concern", "title": "" } ], "title": "Agent creation" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_hybrid_workflow_orchestration[\"Hybrid Workflow Orchestration\"]\n n_dsl_compliance_loading[\"DSL Compliance Loading\"]\n n_agent_workflow_file_modification_recovery[\"Agent Workflow File Modification Recovery\"]\n n_context_forking_configuration[\"Context Forking Configuration\"]\n n_verb_based_execution_classification[\"Verb-Based Execution Classification\"]\n n_workspace_configuration_discovery[\"Workspace Configuration Discovery\"]\n n_shared_document_workspace[\"Shared Document Workspace\"]\n n_workflow_type_document_selection[\"Workflow Type Document Selection\"]\n n_agent_sequence_definition[\"Agent Sequence Definition\"]\n n_agent_document_responsibility[\"Agent Document Responsibility\"]\n n_agent_activation_invocation[\"Agent Activation Invocation\"]\n n_parallel_batch_execution[\"Parallel Batch Execution\"]\n n_sequential_agent_execution[\"Sequential Agent Execution\"]\n n_four_dimensional_agent_graph[\"Four-Dimensional Agent Graph\"]\n n_handoff_signal[\"Handoff Signal\"]\n n_orchestrator_action[\"Orchestrator Action\"]\n n_workflow_coordination_sequence[\"Workflow Coordination Sequence\"]\n n_workflow_recovery_loop[\"Workflow Recovery Loop\"]\n n_checklist_integration[\"Checklist Integration\"]\n n_phase_documentation_template[\"Phase Documentation Template\"]\n n_workflow_principles_mapping[\"Workflow Principles Mapping\"]\n n_capability_invocation_protocol[\"Capability Invocation Protocol\"]\n n_template_assembly[\"Template Assembly\"]\n n_first_time_initiation[\"First-Time Initiation\"]\n n_workflow_validation_gate[\"Workflow Validation Gate\"]\n n_workflow_creation_kernel[\"Workflow Creation Kernel\"]\n n_workflow_orchestration_concern[\"\"]\n n_handoff_signal --> n_orchestrator_action\n n_orchestrator_action --> n_handoff_signal\n n_workflow_creation_kernel --> n_dsl_compliance_loading\n n_workflow_creation_kernel --> n_agent_workflow_file_modification_recovery\n n_workflow_creation_kernel --> n_context_forking_configuration\n n_workflow_creation_kernel --> n_workspace_configuration_discovery\n n_workflow_creation_kernel --> n_shared_document_workspace\n n_workflow_creation_kernel --> n_agent_sequence_definition\n n_workflow_creation_kernel --> n_handoff_signal\n n_workflow_creation_kernel --> n_workflow_coordination_sequence\n n_workflow_creation_kernel --> n_checklist_integration\n n_workflow_creation_kernel --> n_phase_documentation_template\n n_workflow_creation_kernel --> n_capability_invocation_protocol\n n_workflow_creation_kernel --> n_template_assembly\n n_workflow_creation_kernel --> n_workflow_validation_gate\n n_workflow_creation_kernel --> n_workflow_type_document_selection\n n_workflow_creation_kernel --> n_agent_activation_invocation\n n_workflow_creation_kernel --> n_first_time_initiation" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-agent-workflow", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Classify workflow phases by execution verb, run discovery and investigation agents in parallel forked contexts, run action and mutation agents sequentially, and coordinate all agents through shared artifacts and handoff signals.", "term": "Intent" }, { "description": "Multi-agent workflows should parallelize independent knowledge gathering while serializing state-changing work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowObjective → AgentPhases → ExecutionClassification → ParallelDiscovery → SequentialAction → Handoff", "kind": "code", "language": "text", "title": "Flow" }, { "code": "HybridWorkflowOrchestration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nExecutionMode ::= \"PARALLEL\" | \"SEQUENTIAL\"\nParallelPhase ::= \"DISCOVERY\" | \"INVESTIGATION\" | \"RESEARCH\" | \"ANALYSIS\" | \"EXPLORATION\"\nSequentialPhase ::= \"CREATE\" | \"WRITE\" | \"EXECUTE\" | \"VERIFY\" | \"IMPLEMENT\" | \"REFACTOR\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent runs sequentially, even independent discovery — the workflow crawls.", "kind": "code", "language": "text", "title": "Before" }, { "code": "objective → agent sequence → classify by verb → parallel discovery (forked context) + sequential action (normal context) → handoff", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-hybrid-workflow-orchestration", "title": "Hybrid Workflow Orchestration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Load grammar, keyword, operator, workflow, and checklist references before workflow generation, then require generated content to follow the declared DSL, naming, handoff, execution, forking, spawning, and capability rules.", "term": "Intent" }, { "description": "Workflow generation must begin by loading the language and orchestration contracts that constrain output.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DSLSources → Requirements → ComplianceGate → Proceed|Block", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DSLComplianceLoading ::= \"→\" \"→\" \nWorkflowRequirementSet ::= \"agent_dsl_syntax\" \",\" \"agent_oriented_content\" \",\" \"stable_filename_convention\" \",\" \"handoff_protocol\" \",\" \"hybrid_parallel_sequential\" \",\" \"context_isolation\" \",\" \"agent_spawn_mechanism\" \",\" \"capability_invocation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow generated free-form, ignoring the DSL and handoff contracts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "load DSL + keyword + workflow + checklist specs → require{agent-DSL syntax, handoff protocol, hybrid execution, context isolation, agent spawn} → compliance gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dsl-compliance-loading", "title": "DSL Compliance Loading" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "When a file modification conflict occurs, detect the error, re-read the current file, merge the intended delta into the current content, write the complete new version, verify persistence, and log recovery automatically without asking the developer.", "term": "Intent" }, { "description": "State-mutation conflicts are synchronization failures and should trigger deterministic recovery, not a prompt to the developer.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ModificationError → RereadMerge → CompleteRewrite → Verify", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FileModificationRecovery ::= \"→\" \"→\" \"→\" \"→\" \nRecoveryProtocol ::= \"reread-merge-complete-rewrite\" | \"snapshot-restore-on-failure\"\nForbiddenRecovery ::= \"retry_edit_without_recovery\" | \"ask_user_for_tool_error_recovery\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A stale-write conflict re-reads the file and retries the same edit, or stops to ask the developer.", "kind": "code", "language": "text", "title": "Before" }, { "code": "modification error → re-read current → merge the delta into full state → write complete version → verify → log; never retry-without-recovery, never ask for a tool error", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-workflow-file-modification-recovery", "title": "Agent Workflow File Modification Recovery" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Assign forked context to discovery, investigation, and documentation agents; assign normal context to action and validation agents; preserve model and parallel eligibility metadata per agent class.", "term": "Intent" }, { "description": "Context isolation improves independent analysis, while normal context preserves continuity for mutation and validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentClass → ContextMode → ParallelEligibility → ExecutionPolicy", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContextForkingConfiguration ::= \"→\" \"→\" \"→\" \nAgentClass ::= \"discovery\" | \"investigation\" | \"documentation\" | \"action\" | \"validation\"\nContextMode ::= \"fork\" | \"normal\"\nParallelPolicy ::= \"parallel_true\" | \"parallel_false\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every agent shares one context — discovery pollutes the action agent's state.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent class → discovery/investigation/documentation → fork ; action/validation → normal → per-class parallel eligibility preserved", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-context-forking-configuration", "title": "Context Forking Configuration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Extract the primary verb from each agent purpose, classify it against parallel or sequential verb sets, and bind execution mode, context, and parallel eligibility.", "term": "Intent" }, { "description": "Execution mode should be derived from action semantics, not arbitrary phase numbering.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentPurpose → PrimaryVerb → VerbClass → ExecutionMode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VerbExecutionClassification ::= \"→\" \"→\" \"→\" \nParallelVerb ::= \"ANALYZE\" | \"FIND\" | \"EXTRACT\" | \"READ\" | \"DISCOVER\" | \"INVESTIGATE\" | \"RESEARCH\" | \"EXPLORE\" | \"TRACE\"\nSequentialVerb ::= \"CREATE\" | \"WRITE\" | \"EXECUTE\" | \"VERIFY\" | \"IMPLEMENT\" | \"LINK\" | \"ITERATE\" | \"REFACTOR\" | \"DEPLOY\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Execution mode assigned by phase number, not by what the agent does.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent purpose → primary verb → {ANALYZE/FIND/DISCOVER → PARALLEL(fork)} | {CREATE/WRITE/VERIFY → SEQUENTIAL(normal)}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-verb-based-execution-classification", "title": "Verb-Based Execution Classification" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read workspace configuration, extract zones, semantic extensions, root path, agent definitions, shared zone, workflow zone, and task zone before generating any workflow artifacts.", "term": "Intent" }, { "description": "Workflow artifacts must be placed by discovered workspace configuration, not hardcoded paths.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkspaceConfig → Zones → AgentDefinitions → ArtifactBasePath", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkspaceConfigurationDiscovery ::= \"→\" \"→\" \"→\" \"→\" \nArtifactPathPolicy ::= \"shared_zone/workflow_name\" \",\" \"workflow_zone\" \",\" \"task_zone\" \",\" \"no_hardcoded_paths\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Artifact paths hardcoded — the workflow only runs in one layout.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workspace-config → zones + root + agent defs → artifact base = shared_zone/workflow_name; no hardcoded paths", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workspace-configuration-discovery", "title": "Workspace Configuration Discovery" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Pre-create workflow documents once, require every agent to read and edit the same documents, prohibit duplicate versions, and enforce single source of truth across phases.", "term": "Intent" }, { "description": "Multi-agent coordination should refine shared artifacts rather than create divergent outputs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CoreDocuments → PreCreate → AgentReadEdit → SingleSourceValidation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SharedDocumentWorkspace ::= \"→\" \"→\" \"→\" \"→\" \nSharedAccessProtocol ::= \"all_agents_same_documents\" \",\" \"orchestrator_creates\" \",\" \"agents_refine\" \",\" \"append_mode_false\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each agent writes its own output file; findings diverge across N versions.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre-create core documents once → every agent reads + edits the same set → no duplicate versions → single source of truth", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-shared-document-workspace", "title": "Shared Document Workspace" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Analyze workflow objective, classify workflow type, select five to eight semantically distinct core documents, and map each document to a non-overlapping purpose.", "term": "Intent" }, { "description": "Workflow coordination needs the right shared document set for the work type.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowObjective → WorkflowType → CoreDocuments → PurposeMap", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowDocumentSelection ::= \"→\" \"→\" \"→\" \nWorkflowType ::= \"cleanup\" | \"analysis\" | \"refactoring\" | \"documentation\" | \"implementation\" | \"security\" | \"performance\" | \"infrastructure\" | \"migration\"\nCoreDocumentConstraint ::= \"document_count_between_5_and_8\" \",\" \"distinct_logical_purpose\" \",\" \"semantic_names_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Generic output.md / results.md documents with overlapping purpose.", "kind": "code", "language": "text", "title": "Before" }, { "code": "objective → workflow_type{cleanup|analysis|refactoring|security|migration} → 5-8 distinct-purpose documents → one non-overlapping purpose each", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-type-document-selection", "title": "Workflow Type Document Selection" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "For each agent slot, create an agent object with name, type, phase, purpose, methodology, inputs, outputs, validation gates, document responsibilities, focus areas, edit protocol, agent activation, and 4D graph.", "term": "Intent" }, { "description": "An orchestration plan requires agent objects with executable metadata, not just agent names.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentCount → AgentObjectSet → AgentSequence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentSequenceDefinition ::= \"→\" \"→\" \nAgentObject ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A plan that is just a list of agent names, no executable metadata.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent_count → agent objects{name, type, phase, purpose, inputs, outputs, validation gates, doc responsibilities, execution mode, 4D graph}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-sequence-definition", "title": "Agent Sequence Definition" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each core document, require every agent to read current state, identify outdated or incorrect content, remove stale sections, replace with new discoveries, avoid duplicate findings, and maintain single source of truth.", "term": "Intent" }, { "description": "Shared-document workflows should use surgical refinement rather than additive accumulation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Document → Read → DetectStale → Remove → Replace → Deduplicate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentDocumentResponsibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nProhibitedDocumentOperation ::= \"append_only\" | \"duplicate_findings\" | \"new_version_file\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Agents append findings, accumulating duplicates and contradictions.", "kind": "code", "language": "text", "title": "Before" }, { "code": "document → read current state → detect contradictions → remove stale → replace with new → single source of truth (never append, never a new version file)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-document-responsibility", "title": "Agent Document Responsibility" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For every agent activation, construct a spawn invocation with agent type, prompt, description, model, and context; use forked context for parallel agents and normal context for sequential agents.", "term": "Intent" }, { "description": "Orchestrators must execute agents through the runtime spawn primitive, not simulate agent behavior in the main session.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentObject → SpawnInvocation → AgentExecution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AgentActivationInvocation ::= \"→\" \"→\" \nSpawnCall ::= \"agent_type\" \",\" \"prompt\" \",\" \"description\" \",\" \"model\" \",\" \"context_if_parallel\"\nForbiddenOrchestration ::= \"simulate_agent_execution_in_orchestrator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The orchestrator simulates the agent's work in its own session.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent object → spawn primitive{agent_type, prompt, model, context-if-parallel} → real activation; never simulate in the orchestrator", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-agent-activation-invocation", "title": "Agent Activation Invocation" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Accumulate adjacent parallel agents into a batch, invoke all spawns in a single concurrent batch, wait for all completions, and merge findings through shared documents.", "term": "Intent" }, { "description": "Parallel agents should execute concurrently only when their work is investigation-safe and state-isolated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ParallelAgents → ConcurrentSpawnBatch → WaitAll → MergeFindings", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ParallelBatchExecution ::= \"→\" \"→\" \"→\" \nConcurrentSpawnBatch ::= \"single_batch_concurrent_spawn\"\nParallelSafety ::= \"context_fork\" \",\" \"discovery_or_investigation_only\" \",\" \"shared_artifact_refinement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Parallel agents launched in separate messages, so they run one after another anyway.", "kind": "code", "language": "text", "title": "Before" }, { "code": "adjacent parallel agents → one concurrent batch of forked-context spawns → wait for all → merge via shared documents", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-parallel-batch-execution", "title": "Parallel Batch Execution" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Execute state-changing or validation agents one at a time in normal context, pass handoff context from the previous phase, wait for completion signal, then activate the next agent.", "term": "Intent" }, { "description": "Mutating workflow phases must serialize to prevent conflicting edits and ambiguous state.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreviousHandoff → SpawnCall → WaitCompletion → NextHandoff", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SequentialAgentExecution ::= \"→\" \"→\" \"→\" \nSequentialConstraint ::= \"one_spawn_at_a_time\" \",\" \"wait_for_completion\" \",\" \"context_normal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two mutating agents launched at once, producing conflicting edits.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prior handoff → one normal-context spawn at a time → wait for completion → activate the next", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-sequential-agent-execution", "title": "Sequential Agent Execution" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "For each agent, build sequential dependencies, lateral parallel peers, diagonal artifact/data dependencies, and propagation effects including superseded state, propagated contracts, and breakage risks.", "term": "Intent" }, { "description": "Multi-agent workflows need topology, not only order.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Agent → Z + X + Y + W Graph", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FourDAgentGraph ::= \"→\" \",\" \",\" \",\" \nSequentialAxis ::= \"Z: prior_required_agents\"\nLateralAxis ::= \"X: peer_parallel_agents\"\nDiagonalAxis ::= \"Y: cross_phase_artifact_dependencies\"\nPropagationAxis ::= \"W: superseded_state, propagated_contracts, breaks_if_changed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent records only its order, not its cross-phase data or downstream ripple.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent → Z{prior required agents} + X{peer parallel} + Y{cross-phase artifact deps} + W{superseded state, propagated contracts, breaks-if-changed}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-four-dimensional-agent-graph", "title": "Four-Dimensional Agent Graph" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Require every agent to end with a structured handoff signal containing completed agent, phase status, artifact location, next agent, execution mode, context used, findings, files, validation status, parallel results, 4D graph, and orchestrator action.", "term": "Intent" }, { "description": "Handoffs are control messages that preserve workflow state across agent boundaries.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentCompletion → HandoffContext → OrchestratorAction", "kind": "code", "language": "text", "title": "Flow" }, { "code": "HandoffSignal ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nOrchestratorAction ::= \"ACTIVATE_NEXT_AGENT\" | \"PAUSE_FOR_USER\" | \"WORKFLOW_COMPLETE\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action)", "term": "Composes" }, { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An agent finishes with a prose summary the orchestrator cannot route on.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent completion → handoff{completed, phase status, artifacts, next agent, execution mode, context, findings, validation, 4D graph, orchestrator_action}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[Orchestrator Action](/records/algorithms/orchestrator-action)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-handoff-signal", "title": "Handoff Signal" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Interpret handoff action as activate next agent, pause for the developer, or complete workflow; automatically continue unless a critical decision or repeated recovery failure requires the developer's involvement.", "term": "Intent" }, { "description": "The orchestrator is a control loop driven by structured handoff actions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "HandoffSignal → ActionType → Execute|Pause|Complete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "OrchestratorActionHandling ::= \"→\" \"→\" \nActionType ::= \"ACTIVATE_NEXT_AGENT\" | \"PAUSE_FOR_USER\" | \"WORKFLOW_COMPLETE\"\nContinuationRule ::= \"never_ask_should_I_continue\" \",\" \"use_orchestrator_action\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Composes" }, { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Composed by" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The orchestrator asks the developer 'should I continue?' after every agent.", "kind": "code", "language": "text", "title": "Before" }, { "code": "handoff → orchestrator_action{ACTIVATE_NEXT_AGENT | PAUSE_FOR_USER | WORKFLOW_COMPLETE} → auto-continue unless a critical decision or repeated recovery failure", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[Handoff Signal](/records/algorithms/handoff-signal)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-orchestrator-action", "title": "Orchestrator Action" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Pre-create documents, execute parallel batches where eligible, execute sequential agents one at a time, update checkpoints, validate single source of truth, and mark workflow completion.", "term": "Intent" }, { "description": "Coordination is the explicit execution trace for the whole workflow.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PreCreateDocs → ParallelBatch|SequentialTask → Handoff → Checkpoint → Complete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowCoordinationSequence ::= \"→\" \"→\" \"→\" \nWorkflowCompletionState ::= \"WORKFLOW_PROGRESS_100_percent\" \",\" \"core_documents_refined\" \",\" \"final_output_ready\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Coordination left implicit — no record states the spawn order.", "kind": "code", "language": "text", "title": "Before" }, { "code": "pre-create docs → parallel batches where eligible + sequential tasks one at a time → handoffs → checkpoint updates → 100% complete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-coordination-sequence", "title": "Workflow Coordination Sequence" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "If an agent fails validation, read shared documents, identify unmet expectation, research the error pattern, relaunch the agent with adapted context, and pause for the developer after bounded recovery attempts.", "term": "Intent" }, { "description": "Agent failure should trigger bounded evidence-based recovery, not silent continuation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ValidationFail → Diagnose → Research → Relaunch → RetryLimit|Recover", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowRecoveryLoop ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRecoveryDecision ::= \"continue_after_recovery\" | \"pause_for_user_after_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A failed agent is silently skipped and the workflow continues.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validation fail → read shared docs → diagnose unmet expectation → research the error → relaunch with adapted context → pause for the developer after the bound", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-recovery-loop", "title": "Workflow Recovery Loop" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Create a workflow progress checklist in the artifact workspace, include execution model metadata, phases in linear dependency order with severity metadata, task checkboxes, progress bars, success criteria, and agent-edit coordination rules.", "term": "Intent" }, { "description": "Workflow state must persist independently of any one agent context.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workflow → Checklist → AgentUpdates → ResumableProgress", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ChecklistIntegration ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nChecklistCoordinationRule ::= \"orchestrator_precreates\" \",\" \"all_agents_edit_same_checklist\" \",\" \"phase_complete_before_handoff\" \",\" \"resume_by_reading_checklist\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[model_governance](/records/force/model-governance), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow state lives only in the orchestrator context; a restart loses it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workflow → progress checklist{execution model, linear phases + severity metadata, task checkboxes, success criteria} → any agent resumes by reading it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-checklist-integration", "title": "Checklist Integration" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each agent phase, render phase header, execution mode, context mode, methodology, 4D graph, artifact flow, focus areas, deliverable, and agent activation example.", "term": "Intent" }, { "description": "Workflow templates must document how each agent is activated and what it contributes.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentPhase → DocumentationSection → InvocationExample", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseDocumentationTemplate ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A phase documented with no execution mode, graph, or invocation example.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent phase → header + execution mode + context + methodology + 4D graph + artifacts + focus + deliverable + agent activation example", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-documentation-template", "title": "Phase Documentation Template" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Derive workflow principles from the agent sequence, first agent grounding role, final agent quality guarantee, intermediate agent contributions, automation, context awareness, recovery, scalability, hybrid execution, context forking, and workspace integration.", "term": "Intent" }, { "description": "A workflow should state the qualities guaranteed by its orchestration structure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AgentSequence → PrincipleSet → WorkflowValueStatement", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowPrinciplesMapping ::= \"→\" \"→\" \nWorkflowPrinciple ::= \"grounded_in_codebase_reality\" | \"fully_automated\" | \"context_aware\" | \"self_recovering\" | \"dynamically_scalable\" | \"hybrid_execution\" | \"context_forking\" | \"workspace_integrated\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A workflow that never states what its structure guarantees.", "kind": "code", "language": "text", "title": "Before" }, { "code": "agent sequence → per-agent contribution{first grounds, final guarantees quality} → principles{grounded, automated, context-aware, self-recovering, scalable}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-principles-mapping", "title": "Workflow Principles Mapping" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Define specialized capability invocation patterns, classify which capabilities run forked or normal, include examples, and allow workflows to call capabilities for research, validation, calculation, and specialized subroutines.", "term": "Intent" }, { "description": "Workflows should support specialized capabilities without embedding every capability into every agent.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CapabilityNeed → CapabilityPattern → ContextMode → Invocation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CapabilityInvocationProtocol ::= \"→\" \"→\" \"→\" \nCapabilityInvocation ::= \"invoke(capability=name, args=args)\"\nCapabilityContextRule ::= \"discovery_capability_context_fork\" | \"validation_capability_context_normal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every capability baked into every agent instead of a shared, invocable one.", "kind": "code", "language": "text", "title": "Before" }, { "code": "capability need → select → invoke(capability, args){discovery → forked, validation → normal} → integrate result", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-capability-invocation-protocol", "title": "Capability Invocation Protocol" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Assemble frontmatter, workspace config, overview, phase documentation, checklist requirements, orchestration protocol, handoff format, coordination sequence, capability integration, workflow principles, and domain notes into one workflow artifact.", "term": "Intent" }, { "description": "The workflow template is a compiled orchestration contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Sections → FinalTemplate → OutputPath → Write", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemplateAssembly ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nOutputArtifact ::= \"{workflow_output_dir}/{workflow_name}-WORKFLOW.{workflow_ext}\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Workflow sections written ad hoc, missing the handoff format or coordination.", "kind": "code", "language": "text", "title": "Before" }, { "code": "assemble{frontmatter, workspace config, overview, phase docs, checklist, orchestration protocol, handoff format, coordination, capabilities, principles} → {name}-WORKFLOW file", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-template-assembly", "title": "Template Assembly" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "After generating the workflow template, present a summary and request explicit first-run action: execute workflow, edit template, or cancel.", "term": "Intent" }, { "description": "Generation and first execution are separate approval states.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GeneratedWorkflow → UserChoice → Execute|Edit|Cancel", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FirstTimeInitiation ::= \"→\" \"→\" \"→\" \nUserChoice ::= \"Execute Workflow\" | \"Edit Template\" | \"Cancel\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The generated workflow auto-executes without the developer's go-ahead.", "kind": "code", "language": "text", "title": "Before" }, { "code": "generated workflow → summary → developer choice{Execute | Edit Template | Cancel} → generation and first execution are separate approvals", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-first-time-initiation", "title": "First-Time Initiation" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate DSL compliance, workspace discovery, dynamic agent count, execution classification, context configuration, 4D graphs, handoff protocol, hybrid execution, checklist integration, capability integration, template assembly, dynamic paths, uppercase filenames, and agent-oriented content.", "term": "Intent" }, { "description": "A workflow template is complete only when orchestration, artifact, context, and validation contracts all pass.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "WorkflowTemplate → GateSet → Valid|Invalid", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowValidationGate ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nCompletionVerdict ::= \"workflow_template_valid\" | \"workflow_template_invalid\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Composed by" }, { "description": "[Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A workflow shipped without checking its handoff, 4D graphs, or dynamic paths.", "kind": "code", "language": "text", "title": "Before" }, { "code": "template → checks{DSL, workspace, agent sequence, execution mode, 4D graph, handoff, checklist, capabilities, artifact paths} → valid | invalid", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-validation-gate", "title": "Workflow Validation Gate" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Load DSL and orchestration references, configure file recovery and context forking, discover workspace zones and agents, select shared documents, define dynamic agent sequence, classify execution mode, build 4D graphs, define handoff protocol, assemble coordination sequence, integrate checklist and capabilities, generate phase documentation, assemble template, and validate success criteria.", "term": "Intent" }, { "description": "Workflow creation is a compiler from objective and workspace configuration into an executable multi-agent orchestration contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Specs → Workspace → Documents → Agents → Graphs → Handoffs → Coordination → Checklist → Capabilities → Template → Validation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "WorkflowCreationKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Handoff Signal](/records/algorithms/handoff-signal), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Template Assembly](/records/algorithms/template-assembly), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [metaprogramming_modeling](/records/force/metaprogramming-modeling), [control_coordination](/records/force/control-coordination), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Orchestration](/records/architecture/orchestration)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading)", "term": "orient" }, { "description": "[Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection)", "term": "derive" }, { "description": "[Agent Sequence Definition](/records/algorithms/agent-sequence-definition)", "term": "project" }, { "description": "[Agent Activation Invocation](/records/algorithms/agent-activation-invocation)", "term": "act" }, { "description": "[Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "verify" }, { "description": "[Template Assembly](/records/algorithms/template-assembly)", "term": "commit" }, { "description": "[First-Time Initiation](/records/algorithms/first-time-initiation)", "term": "terminate" } ], "kind": "glossary" }, { "code": "An objective turned straight into a hardcoded, single-threaded agent script.", "kind": "code", "language": "text", "title": "Before" }, { "code": "load specs → discover workspace → select docs → define agents → classify execution → 4D graphs → handoffs → coordinate → checklist + capabilities → assemble → validate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the workflow validation gate, which checks the orchestration, artifact, context and validation contracts, the structured-document validator over the workflow template", "term": "Checked by" }, { "description": "Every workflow template and every agent it sequences", "term": "Population" }, { "description": "A verdict stands until the template, an agent it sequences or the workspace configuration changes", "term": "Freshness" }, { "description": "The gate refuses to mark a template complete while any of its contracts fails", "term": "Refusal" }, { "description": "The coordination record each run writes, which locates a failed handoff", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The workflow template's contracts, which each run's coordination record is compared against", "term": "Authoritative side" }, { "description": "[DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Handoff Signal](/records/algorithms/handoff-signal), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Template Assembly](/records/algorithms/template-assembly), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-workflow-creation-kernel", "title": "Workflow Creation Kernel" }, { "blocks": [ { "items": [ "Domain: [agent-workflow](/records/algorithms-domain/agent-workflow)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → \"→\" \"→\" \"→\" \"→\" \nPurityConstraint ::= \"no_hidden_state\" \",\" \"no_hidden_time\" \",\" \"no_hidden_randomness\" \",\" \"referential_transparency\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Correctness Verification](/records/algorithms/correctness-verification), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "function scoreFoo(f) { return f.base * (Date.now() % 2 ? 1.1 : 1); }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "function scoreFoo(f: Foo, now: Date) { return f.base * rateAt(now); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-deterministic-core", "title": "Deterministic Core" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Define executable architecture rules, validate with static analysis, specification tests, property tests, and runtime checks, then block release when critical rules fail.", "term": "Intent" }, { "description": "Architecture must be continuously verified by fitness functions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Rule → Test → Evidence → Pass|Fail → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VerificationFitness ::= \"→\" \"→\" \"→\" \nVerificationMethod ::= \"type_check\" | \"static_analysis\" | \"schema_validation\" | \"contract_test\" | \"property_based_test\" | \"specification_test\" | \"formal_verification\" | \"runtime_validation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "reviewChecklist.push(\"domain must not import infra\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "test(\"domain imports no infra\", () => expect(importsOf(\"domain\")).not.toContain(\"infra\"));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-verification-fitness", "title": "Verification Fitness" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect invalid state early, fail fast for programmer errors, fail safe for recoverable runtime faults, fail secure for security-sensitive failures, and return typed errors.", "term": "Intent" }, { "description": "Error handling is a contract for containment, disclosure, and recovery.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Operation → Guard → ErrorClass → BoundaryPolicy → RecoveryOrAbort", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ErrorBoundary ::= \"→\" \"→\" \"→\" \"→\" \nFailurePolicy ::= \"fail_fast\" | \"fail_safe\" | \"fail_secure\" | \"graceful_degradation\" | \"fallback\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Construction Boundary](/records/algorithms/governed-construction-boundary)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [resilience_recovery](/records/force/resilience-recovery), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "try { doFoo(); } catch (e) { return null; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "try { return ok(doFoo()); } catch (e) {\n if (isProgrammerError(e)) throw e;\n Logger.error(\"doFoo failed\", e); return err(\"foo.retry\");\n}", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-error-boundary", "title": "Error Boundary" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "Wrap remote or unreliable calls with timeout, retry, circuit breaker, bulkhead isolation, fallback, and backpressure policies.", "term": "Intent" }, { "description": "Resilience is controlled failure under resource and dependency stress.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Call → Timeout → RetryPolicy → CircuitBreaker → Bulkhead → Fallback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResilienceControl ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nRetryPolicy ::= \"bounded_attempts\" \",\" \"jittered_backoff\" \",\" \"idempotency_required\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Composed by" }, { "description": "[resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const r = await callFoo(url);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const r = await breaker.run(() => withTimeout(callFoo(url), 2000), { retries: 3, backoff: jitter });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-resilience-control", "title": "Resilience Control" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Yields: boolean | counter" ], "kind": "list" }, { "entries": [ { "description": "Continuously health-check services, isolate failed instances, fail over to redundancy, roll back unsafe releases, and use canary or blue-green deployment for controlled exposure.", "term": "Intent" }, { "description": "Deployment safety requires observable health and reversible rollout.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Deploy → HealthCheck → TrafficShift → DetectFailure → Rollback|Promote", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RecoveryDeployment ::= \"→\" \"→\" \"→\" \nDeploymentStrategy ::= \"blue_green\" | \"canary\" | \"rolling\" | \"rollback\" | \"auto_remediation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[resilience_recovery](/records/force/resilience-recovery), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "deployAll(fooV2);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "canary(fooV2, { percent: 5, healthCheck });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-recovery-deployment", "title": "Recovery Deployment" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Attach correlation and causation identifiers to every operation, emit structured logs, metrics, traces, and audit records, then connect them into an explainable execution graph.", "term": "Intent" }, { "description": "A system is operable only when behavior can be reconstructed from evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Request → CorrelationID → Logs/Metrics/Traces → Audit → CausalGraph", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ObservabilityTrace ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTelemetryEvent ::= \"log\" | \"metric\" | \"trace_span\" | \"alert\" | \"audit_log\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Event and Messaging Consistency](/records/algorithms/event-and-messaging-consistency)", "term": "Composed by" }, { "description": "[observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "console.log(\"processing foo\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "logger.info(\"foo.process\", { correlationId: ctx.cid, causationId: ctx.parentId, fooId: foo.id });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-observability-trace", "title": "Observability Trace" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model events as a dependency graph, assign causal metadata, preserve happens-before relationships with sequence numbers, Lamport clocks or vector clocks where physical timestamps are insufficient, and reject or compensate for invalid ordering.", "term": "Intent" }, { "description": "Distributed correctness depends on causal ordering, not just timestamps.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Event → CausalMetadata → DependencyGraph → OrderingValidation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CausalityOrdering ::= \"→\" \"→\" \"→\" \nCausalMetadata ::= \"correlation_id\" | \"causation_id\" | \"sequence_number\" | \"lamport_clock\" | \"vector_clock\"\nDependencyGraph ::= \"DAG\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "events.sort((a, b) => a.timestamp - b.timestamp);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "events.sort(byVectorClock);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-causality-ordering", "title": "Causality Ordering" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Measure workload, identify bottlenecks, choose vertical or horizontal scaling, partition load, cache safe data, enforce rate limits, and benchmark continuously.", "term": "Intent" }, { "description": "Scalability is achieved by measured bottleneck removal, not speculative optimization.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workload → Profile → Bottleneck → ScaleStrategy → Benchmark → Feedback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PerformanceScaling ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nScalingStrategy ::= \"vertical_scaling\" | \"horizontal_scaling\" | \"load_balancing\" | \"sharding\" | \"partitioning\" | \"caching\" | \"stateless_replication\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[performance_scaling](/records/force/performance-scaling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "optimizeEverywhere(app);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const hot = profile(load).topBottleneck();\nscale(hot, hot.isCpuBound ? \"horizontal\" : \"cache\"); benchmark();", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-performance-scaling", "title": "Performance Scaling" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Cache only data with defined freshness, key identity, invalidation triggers, consistency expectations, and fallback behavior.", "term": "Intent" }, { "description": "Caching is safe only when staleness and invalidation are explicit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Data → CacheKey → FreshnessPolicy → Invalidation → ReadThrough|Bypass", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CacheContract ::= \"→\" \"→\" \"→\" \"→\" \nConsistencyPolicy ::= \"strong\" | \"eventual\" | \"read_your_writes\" | \"bounded_staleness\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "cache.set(key, value);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "cache.set(fingerprint(inputs, deriverVersion), value, { invalidateOn: [\"FooChanged\"], consistency: \"read_your_writes\" });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cache-correctness", "title": "Cache Correctness" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Externalize configuration, standardize protocols, isolate platform assumptions behind adapters, package runtime dependencies, and validate parity across environments.", "term": "Intent" }, { "description": "Portable systems separate behavior from deployment substrate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Code → ExternalConfig → StandardProtocol → Container|Package → EnvironmentParity", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PortabilityContract ::= \"→\" \"→\" \"→\" \"→\" \nEnvironmentValidation ::= \"dev\" \",\" \"test\" \",\" \"staging\" \",\" \"production\" \",\" \"parity_check\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const db = connect(\"driver://prod-host:5432\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const db = connect(config.databaseUrl);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-portability-environment", "title": "Portability Environment" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, protect secrets, and enforce policy continuously.", "term": "Intent" }, { "description": "Security is a default-deny contract over identity, data, and operations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ThreatModel → Identity → Authorization → Validation → Protection → Audit", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SecurityPolicy ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nAccessDecision ::= \"RBAC\" | \"ABAC\" | \"least_privilege\" | \"zero_trust\"\nDataProtection ::= \"encryption_at_rest\" \",\" \"encryption_in_transit\" \",\" \"secrets_management\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Construction Boundary](/records/algorithms/governed-construction-boundary)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "if (user) allowFoo();", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "if (!policy.can(user, \"foo:write\", resource)) throw forbidden();\nconst foo = validate(FooSchema, input);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-security-policy", "title": "Security Policy" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Separate control concerns from data execution, centralize policy/configuration/authentication/logging where beneficial, and decentralize runtime execution where autonomy is required.", "term": "Intent" }, { "description": "A control plane coordinates policy while data planes execute work.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → ControlPlane → DistributedExecution → Feedback", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ControlPlane ::= \"→\" \"→\" \"→\" \"→\" \nCentralizedCoordination ::= \"configuration\" | \"authentication\" | \"authorization\" | \"logging\" | \"orchestration\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Control Plane Coordination](/records/algorithms/control-plane-coordination)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[Control Plane](/records/architecture/control-plane)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every service reads its own ad-hoc config and does its own auth — policy is scattered and drifts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "policy{central} → control-plane{config, auth, orchestration} → data-planes{Foo, Bar execute work} → telemetry-feedback → policy-adjustment", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-control-plane", "title": "Control Plane" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Represent behavior as data, validate the model or DSL, compile or interpret it into runtime behavior, and restrict reflection or code generation behind safety contracts.", "term": "Intent" }, { "description": "Metaprogramming is safe when code-as-data has schema, validation, and bounded execution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Model → Schema → Compile|Interpret → RuntimeBehavior → SafetyCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DeclarativeMetaprogramming ::= \"→\" \"→\" \"→\" \"→\" \nTransformationEngine ::= \"reflection\" | \"introspection\" | \"compile_time_evaluation\" | \"runtime_code_generation\" | \"DSL_interpreter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "eval(fooExpression);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const ast = parse(fooDsl, GRAMMAR); validate(ast, SCHEMA); run(compile(ast), sandbox);", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-declarative-metaprogramming", "title": "Declarative Metaprogramming" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Process data sequentially through bounded pipeline stages, preserve forward-only semantics where required, apply backpressure, checkpoint state where needed, and keep stages stateless unless state is explicitly modeled.", "term": "Intent" }, { "description": "Streaming systems are contracts over flow, order, pressure, and bounded memory.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Source → Stage → Stage → Sink → Checkpoint", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StreamingDataflow ::= \"→\" \"→\" \"→\" \"→\" \nPipelineStage ::= \"→\" \"→\" \nProcessingMode ::= \"single_pass\" | \"lazy_evaluation\" | \"sequential_access\" | \"forward_only\" | \"stateless\" | \"stateful_with_checkpoint\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [resilience_recovery](/records/force/resilience-recovery), [streaming_dataflow](/records/force/streaming-dataflow), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const all = await loadAllFoo(); return all.map(toBar).filter(isBaz);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "fooSource.pipe(mapStage(toBar)).pipe(filterStage(isBaz)).pipe(sink, { backpressure: true });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-streaming-dataflow", "title": "Streaming Dataflow" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Retrieve knowledge from indexed sources, validate relevance and freshness, ground generation in retrieved evidence, and distinguish known, inferred, and unsupported output.", "term": "Intent" }, { "description": "Retrieval-augmented systems must separate source evidence from generated synthesis.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Query → Retrieve → Rank → Ground → Generate → Cite|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RAGBoundary ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nEvidenceDisclosure ::= \"supported\" | \"partially_supported\" | \"unsupported_reject_or_disclose\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Profile Compose](/records/algorithms/profile-compose), [Delta Capture](/records/algorithms/delta-capture)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const answer = model.generate(query);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const ev = retrieve(query);\nconst g = generate(query, ev);\nreturn g.supported ? cite(g, ev) : disclose(\"unsupported\");", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-rag-knowledge-boundary", "title": "RAG Knowledge Boundary" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a concern, classify its force type, select the corresponding contract family, compose required invariants, bind implementation patterns, and attach validation gates.", "term": "Intent" }, { "description": "Architectural patterns are reusable only when selected by force, not by name.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concern → ForceType → ContractFamily → PatternSet → ValidationGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureSelection ::= \"→\" \"→\" \"→\" \"→\" \nForceFamily ::= \"modularity\" | \"compatibility\" | \"semantics\" | \"extension\" | \"state\" | \"correctness\" | \"resilience\" | \"security\" | \"scale\" | \"governance\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pattern chosen by name ('let's use Foo') before the force it must resolve is known.", "kind": "code", "language": "text", "title": "Before" }, { "code": "concern → force{change-isolation} → contract-family{deployment-boundary} → pattern{selected by force, not by name} → validation-gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-selection-meta-algorithm", "title": "Architecture Selection Meta-Algorithm" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For any architectural concern, define its intent, boundary, contract, invariants, allowed variation, forbidden leakage, validation strategy, observability model, and evolution policy.", "term": "Intent" }, { "description": "Every architecture principle can be operationalized as a bounded contract with verification and change rules.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Intent → Boundary → Contract → Invariant → Variation → Validation → Evolution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "UniversalConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nContract ::= \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A principle stated as prose ('be modular') with no operational contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "intent → boundary → contract{in, out, pre, post} → invariants → allowed-variation → forbidden-leakage → validation → observability → evolution", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-universal-architectural-concern-template", "title": "Universal Architectural Concern Template" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → ", "term": "Intent" }, { "description": "Architecture becomes reproducible when every named principle is reduced to a force, every force becomes a contract, every contract has invariants, and every invariant has validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Force → Contract → Pattern → Implementation → Verification → Operation → Evolution", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalContractAlgebra ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nForce ::= \"change\" | \"dependency\" | \"semantic_consistency\" | \"runtime_extension\" | \"state_mutation\" | \"failure\" | \"scale\" | \"security\" | \"governance\" | \"intelligence\"\nBoundary ::= | | | | | | \nPattern ::= | | | | | | \nVerification ::= | | | | | | \nEvolution ::= | | | | | ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Design by Contract](/records/architecture/design-by-contract)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-contract-algebra", "title": "Architectural Contract Algebra" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For a module whose public surface is machine-derivable, make its metadata manifest the single documentation source of truth: authored narrative lives in mandated, shape-validated manifest fields (with self-expanding custom fields), the API surface is collected deterministically from the built type-declarations, one marker-layered document is compiled per module from both, and a governance router runs the context-detection rules on the manifest strings where a manifest governs (rendering each field to its markdown fragment first) and on the document itself where none exists. Beyond the module document, a manifest may declare typed documents — each a form plus concern that routes through the pure location function to a computed path — generated and drift-checked the same way, so the manifest is the single content generator with no separate template mechanism.", "term": "Intent" }, { "description": "A module's document is well-formed iff it recompiles byte-identical from its manifest docs-block plus its derived surface, its docs-block satisfies the mandated schema with every custom field a renderable shape, and every governed string passes the context rules reported at its manifest field; the manifest, where present, is the governed surface and the document is exempt and drift-checked.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Manifest → AuthoredField → DerivedSurface → SectionDeriver → MarkerLayer → Compilation → GovernanceRouter → DriftGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModuleDocument ::= \"+\" \"→\" \"→\" \"→\" \"→\" \nGovernanceRouter ::= \"→\" | \"→\" \nTypedDocument ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Document Truth Alignment](/records/algorithms/document-truth-alignment), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [contract_compatibility](/records/force/contract-compatibility), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A README hand-authored as prose that drifts from the exports it claims to document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "manifest.docs{authored} + derivedSurface{from .d.ts} → section-derivers → marker-template → compile → drift-gate{recompiles byte-identical, else fail}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Document Truth Alignment](/records/algorithms/document-truth-alignment), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-manifest-driven-documentation", "title": "Manifest-Driven Documentation" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For any reusable package that must stay agnostic of the applications consuming it, hardcode zero consumer-specific truths in package source; declare every consumer-specific value in one consumer-owned config of typed sections, load it through a framework the leaf packages never import, and hand each package only the section it needs through an injection surface — so a package drops into any consumer without a literal about that consumer leaking through its source.", "term": "Intent" }, { "description": "A package is consumer-agnostic iff every consumer-specific value it depends on arrives by injection at wiring time and no consumer token, path, or config-location appears in its source; the one consumer config is the single reader-visible source of those values and a static gate rejects any re-hardcoding.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConsumerValue → ConfigSection → FrameworkLoad → InjectionSurface → PackageConsumption → CouplingGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConsumerConfigSSOT ::= \"→\" \"→\" \"→\" \"→\" \"+\" \nInjectionSurface ::= \"|\" \"|\" \"|\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const ROOT = \"my-app\";\nconst cfg = read(\"../config/app.json\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export function createFoo(opts: { root: string; store: FooStore }) { return new Foo(opts); }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-consumer-config-ssot", "title": "Consumer Config SSOT" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model behavior as a finite set of states with explicit legal transitions, so illegal state combinations are unrepresentable.", "term": "Intent" }, { "description": "Every runtime state is one of the declared states and every transition is a declared edge.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EnumerateStates → DefineEvents → DeclareTransitions → RejectUndeclared", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FiniteStateMachine ::= \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[State Pattern](/records/algorithms/state-pattern), [Structural Core](/records/algorithms/structural-core)", "term": "Composes" }, { "description": "[Statecharts](/records/algorithms/statecharts)", "term": "Composed by" }, { "description": "boolean-flag-soup (illegal-states)", "term": "Forces" }, { "description": "[Finite State Machine](/records/architecture/finite-state-machine)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "let isOpen = false, isLoading = false, isError = false;\nfunction onClick() { isLoading = true; if (isOpen) isOpen = false; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "type FooState = \"closed\" | \"loading\" | \"open\" | \"error\";\nconst transitions: Record>> = {\n closed: { open: \"loading\" },\n loading: { ready: \"open\", fail: \"error\" },\n open: { close: \"closed\" },\n error: { retry: \"loading\" },\n};\nfunction next(state: FooState, event: FooEvent): FooState { return transitions[state][event] ?? state; }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[State Pattern](/records/algorithms/state-pattern), [Structural Core](/records/algorithms/structural-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-finite-state-machine", "title": "Finite State Machine" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Extend a flat state machine with hierarchy and parallel regions, so independent concerns compose without state explosion.", "term": "Intent" }, { "description": "Independent behavioral concerns live in separate parallel regions rather than a cross product of flat states.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "IdentifyIndependentConcerns → NestRelatedStates → SeparateParallelRegions → GuardTransitions", "kind": "code", "language": "text", "title": "Flow" }, { "code": "Statecharts ::= \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Finite State Machine](/records/algorithms/finite-state-machine), [Separation of Concerns](/records/algorithms/separation-of-concerns)", "term": "Composes" }, { "description": "flat-state-explosion (combinatorial-growth)", "term": "Forces" }, { "description": "[Statecharts](/records/architecture/statecharts)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "type S = \"idleMuted\" | \"idleLoud\" | \"playingMuted\" | \"playingLoud\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const fooChart = {\n initial: \"idle\",\n states: { idle: {}, playing: {} },\n parallel: { volume: { states: { muted: {}, loud: {} } } },\n};", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Finite State Machine](/records/algorithms/finite-state-machine), [Separation of Concerns](/records/algorithms/separation-of-concerns)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-statecharts", "title": "Statecharts" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Model concurrent flow as places, tokens, and transitions, so reachability and deadlock are analyzable before runtime.", "term": "Intent" }, { "description": "Concurrent progress is expressed as token flow through transitions whose enabling conditions are explicit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DefinePlaces → PlaceTokens → DefineTransitions → AnalyzeReachability → AssertNoDeadlock", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PetriNet ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Concurrency Correctness](/records/algorithms/concurrency-correctness), [Correctness Core](/records/algorithms/correctness-core)", "term": "Composes" }, { "description": "ad-hoc-lock-ordering (deadlock)", "term": "Forces" }, { "description": "[Petri Nets](/records/architecture/petri-nets)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "acquire(a); acquire(b); work(); release(b); release(a);", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const net = petriNet({\n places: { idle: 1, aHeld: 0, bHeld: 0 },\n transitions: [\n { name: \"takeA\", consume: { idle: 1 }, produce: { aHeld: 1 } },\n { name: \"takeB\", consume: { aHeld: 1 }, produce: { bHeld: 1 } },\n ],\n});\nassertNoDeadlock(reachableMarkings(net));", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Concurrency Correctness](/records/algorithms/concurrency-correctness), [Correctness Core](/records/algorithms/correctness-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-petri-nets", "title": "Petri Nets" }, { "blocks": [ { "items": [ "Domain: [architecture](/records/algorithms-domain/architecture)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Size a system from arrival and service rates, so capacity and wait time are predicted rather than guessed.", "term": "Intent" }, { "description": "Utilization stays below one and predicted wait time is derived from the arrival/service-rate model.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MeasureArrivalRate → MeasureServiceRate → ComputeUtilization → PredictWaitTime → SizeServers", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QueuingModel ::= \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Capacity Planning](/records/algorithms/capacity-planning), [Performance Core](/records/algorithms/performance-core)", "term": "Composes" }, { "description": "guess-based-capacity (saturation)", "term": "Forces" }, { "description": "[Queuing Theory](/records/architecture/queuing-theory)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const workers = 4;", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const rho = arrivalRate / (workers * serviceRate);\nif (rho >= 1) throw new Error(\"unstable queue: utilization >= 1\");\nconst avgWaitMs = mm1WaitTime({ arrivalRate, serviceRate, servers: workers });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the fitness functions, contract tests and architecture tests each contract names, the reviews a contract names where no automated check exists", "term": "Checked by" }, { "description": "Every module and boundary the contract governs", "term": "Population" }, { "description": "A verdict stands until the module, its dependencies or the contract changes", "term": "Freshness" }, { "description": "A failing fitness function or contract test blocks the release", "term": "Refusal" }, { "description": "The traces and health signals the observability contracts require, which locate a contract failure in production", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The contract, which the module and its tests conform to", "term": "Authoritative side" }, { "description": "[Capacity Planning](/records/algorithms/capacity-planning), [Performance Core](/records/algorithms/performance-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-queuing-theory", "title": "Queuing Theory" } ], "title": "Architecture" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_architectural_relationship_record[\"Architectural Relationship Record\"]\n n_architecture_knowledge_graph[\"Architecture Knowledge Graph\"]\n n_architectural_force_classification[\"Architectural Force Classification\"]\n n_dependency_closure[\"Dependency Closure\"]\n n_reinforcement_propagation[\"Reinforcement Propagation\"]\n n_conflict_and_tension_resolution[\"Conflict and Tension Resolution\"]\n n_severity_policy[\"Severity Policy\"]\n n_violation_detection[\"Violation Detection\"]\n n_measurement_normalization[\"Measurement Normalization\"]\n n_refactor_selection[\"Refactor Selection\"]\n n_enforcement_gate[\"Enforcement Gate\"]\n n_architecture_assessment[\"Architecture Assessment\"]\n n_modular_boundary_compliance[\"Modular Boundary Compliance\"]\n n_contract_compatibility[\"Contract Compatibility\"]\n n_canonical_semantics[\"Canonical Semantics\"]\n n_self_description_and_discovery[\"Self-Description and Discovery\"]\n n_runtime_extensibility[\"Runtime Extensibility\"]\n n_pattern_selection[\"Pattern Selection\"]\n n_event_and_messaging_consistency[\"Event and Messaging Consistency\"]\n n_state_and_transaction_safety[\"State and Transaction Safety\"]\n n_correctness_verification[\"Correctness Verification\"]\n n_resilience_policy[\"Resilience Policy\"]\n n_observability_and_auditability[\"Observability and Auditability\"]\n n_performance_and_scalability[\"Performance and Scalability\"]\n n_security_governance[\"Security Governance\"]\n n_architecture_evolution_governance[\"Architecture Evolution Governance\"]\n n_control_plane_coordination[\"Control Plane Coordination\"]\n n_metaprogramming_safety[\"Metaprogramming Safety\"]\n n_model_lifecycle_governance[\"Model Lifecycle Governance\"]\n n_architectural_recommendation[\"Architectural Recommendation\"]\n n_architecture_fitness_function_generation[\"Architecture Fitness Function Generation\"]\n n_architecture_refactoring_roadmap[\"Architecture Refactoring Roadmap\"]\n n_concept_cluster_extraction[\"Concept Cluster Extraction\"]\n n_architecture_decision_support[\"Architecture Decision Support\"]\n n_relationship_schema_validation[\"Relationship Schema Validation\"]\n n_architecture_catalog_compiler[\"Architecture Catalog Compiler\"]\n n_master_architecture_governance_kernel[\"Master Architecture Governance Kernel\"]\n n_architectural_relationship_algebra[\"Architectural Relationship Algebra\"]\n n_architecture_assessment --> n_dependency_closure\n n_architecture_assessment --> n_violation_detection\n n_architecture_assessment --> n_measurement_normalization\n n_architecture_evolution_governance --> n_architecture_assessment\n n_architectural_recommendation --> n_dependency_closure\n n_architecture_fitness_function_generation --> n_architectural_relationship_record\n n_architecture_fitness_function_generation --> n_enforcement_gate\n n_architecture_fitness_function_generation --> n_severity_policy\n n_master_architecture_governance_kernel --> n_relationship_schema_validation\n n_master_architecture_governance_kernel --> n_concept_cluster_extraction\n n_master_architecture_governance_kernel --> n_dependency_closure\n n_master_architecture_governance_kernel --> n_violation_detection\n n_master_architecture_governance_kernel --> n_measurement_normalization\n n_master_architecture_governance_kernel --> n_refactor_selection\n n_master_architecture_governance_kernel --> n_enforcement_gate\n n_master_architecture_governance_kernel --> n_architecture_decision_support\n n_architectural_relationship_algebra --> n_dependency_closure\n n_architectural_relationship_algebra --> n_violation_detection\n n_architectural_relationship_algebra --> n_measurement_normalization\n n_architectural_relationship_algebra --> n_refactor_selection\n n_architectural_relationship_algebra --> n_enforcement_gate\n n_architectural_relationship_algebra --> n_architecture_evolution_governance" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-arch-relationships", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Represent every architectural concept as a typed relationship record containing scope, dependencies, reinforcing effects, enabled capabilities, conflicts, tensions, violations, detection signals, metrics, refactor actions, enforcement mechanisms, and severity.", "term": "Intent" }, { "description": "An architecture principle becomes operational when it is converted from a name into a measurable, enforceable relationship contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concept → Type → Scope → Requires → Violations → Detection → Measurement → Refactor → Enforcement → Severity", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalRelationshipRecord ::= \":\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \",\" \nRecordType ::= \"Principle\" | \"Quality Attribute\" | \"Contract\" | \"Architecture Style\" | \"Pattern\" | \"Mechanism\" | \"Metric\" | \"Practice\"\nEnforcementSeverity ::= \"mandatory\" | \"recommended\" | \"contextual\" | \"discouraged\"\nMandatoryFor ::= \"contextual\" \"+\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Low Coupling' as a bare name in a list — not measurable, not enforceable.", "kind": "code", "language": "text", "title": "Before" }, { "code": "Low Coupling : Quality-Attribute, scope{module}, requires{Abstraction}, conflicts_with{Tight Coupling}, detected_by{cycle scan}, measured_by{coupling metric}, refactored_by{invert dependency}, enforced_by{dependency rule}, severity{mandatory}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-relationship-record", "title": "Architectural Relationship Record" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Parse all relationship records into a directed multigraph where concepts are nodes and fields such as requires, reinforces, enables, conflicts, tensions, detects, measures, refactors, and enforces are typed edges.", "term": "Intent" }, { "description": "The architecture catalog becomes reusable when its relationships can be traversed as a graph.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Records → Nodes → TypedEdges → Graph → QueryableArchitectureModel", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureGraph ::= \",\" \nConceptNode ::= \",\" \",\" \",\" \nRelationshipEdge ::= \"→\" \"→\" \nRelationType ::= \"requires\" | \"reinforces\" | \"enables\" | \"conflicts_with\" | \"tensions_with\" | \"violated_by\" | \"detected_by\" | \"measured_by\" | \"refactored_by\" | \"enforced_by\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A flat list of relationship records — no way to ask 'what does Foo require, transitively?'", "kind": "code", "language": "text", "title": "Before" }, { "code": "records → nodes{concepts} + typed-edges{requires, reinforces, enables, conflicts_with} → traversable graph", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-knowledge-graph", "title": "Architecture Knowledge Graph" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Given a design issue or desired quality, classify it into a force family, then select all concepts whose scope, type, violation signals, and enabled capabilities match that force.", "term": "Intent" }, { "description": "Architectural decisions should be selected by force and evidence, not by pattern name recognition.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Issue → ForceFamily → CandidateConcepts → ApplicableContracts", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ForceClassification ::= \"→\" \"→\" \"→\" \nForceFamily ::= \"modularity\" | \"contract_compatibility\" | \"semantic_consistency\" | \"domain_boundary\" | \"runtime_extensibility\" | \"object_creation\" | \"structural_mediation\" | \"behavioral_variation\" | \"event_messaging\" | \"state_transaction\" | \"correctness_verification\" | \"resilience_recovery\" | \"observability_traceability\" | \"causality_ordering\" | \"performance_scaling\" | \"security_governance\" | \"architecture_evolution\" | \"control_coordination\" | \"metaprogramming_modeling\" | \"streaming_dataflow\" | \"model_governance\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A design issue answered by pattern-name recall ('use a Factory').", "kind": "code", "language": "text", "title": "Before" }, { "code": "issue{concrete constructor everywhere} → force{object_creation} → concept-query → applicable{Construction Boundary}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-force-classification", "title": "Architectural Force Classification" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "For any target architectural concept, recursively collect its required concepts until no new requirements remain, then order the closure by dependency depth before implementation.", "term": "Intent" }, { "description": "A principle cannot be adopted safely unless its prerequisites are also satisfied.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetConcept → RequiresEdges → TransitiveClosure → DependencyOrder", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DependencyClosure ::= \"→\" \"→\" \"→\" \nRequiresTraversal ::= \"follow requires edges until fixed point\"\nTopologicalOrder ::= \"prerequisites_before_dependents\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Architectural Recommendation](/records/algorithms/architectural-recommendation), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Adopt Foo without checking what Foo needs — its prerequisites are silently unmet.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target{Foo} → follow requires-edges to fixed point → {Bar, Baz} → topological order{Baz, Bar, Foo}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dependency-closure", "title": "Dependency Closure" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "When a concept is implemented or strengthened, traverse its reinforces and enables edges to identify secondary quality gains and architecture capabilities unlocked.", "term": "Intent" }, { "description": "Architecture improvements produce second-order effects through reinforcing relationships.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ImplementedConcept → Reinforces + Enables → CapabilityImpact", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReinforcementPropagation ::= \"→\" \"→\" \"→\" \nImpactSet ::= \",\" \nQualityGain ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Foo implemented; its second-order gains go unnoticed and unclaimed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "satisfied{Foo} → reinforces → {Bar quality} → enables → {Baz capability} → impact set with confidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-reinforcement-propagation", "title": "Reinforcement Propagation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For each selected concept, collect conflicts and tensions, classify conflicts as prohibitive or resolvable, classify tensions as trade-offs, and require an explicit decision when severity or impact is high.", "term": "Intent" }, { "description": "Architecture is not only principle application; it is trade-off governance.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CandidateConcept → Conflicts + Tensions → TradeoffAnalysis → Decision", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConflictTensionResolution ::= \"→\" \"→\" \"→\" \nResolutionPolicy ::= \"reject_combination\" | \"accept_with_mitigation\" | \"document_tradeoff\" | \"require_architecture_decision\" | \"contextual_override\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two chosen concepts silently conflict at runtime; the developer never decided the trade-off.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidates{Foo, Bar} → conflict{prohibitive} → tension{trade-off} → policy{require architecture decision}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-conflict-and-tension-resolution", "title": "Conflict and Tension Resolution" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Interpret severity as an enforcement policy: mandatory concepts become gates, recommended concepts become review findings, contextual concepts require scope justification, and discouraged concepts require explicit exception approval.", "term": "Intent" }, { "description": "Severity converts architecture knowledge into governance behavior.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Severity → EnforcementMode → GateBehavior", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SeverityPolicy ::= \"→\" \nEnforcementMode ::= \"blocking_gate\" | \"review_warning\" | \"context_required\" | \"exception_required\" | \"informational\"\nSeverityMapping ::= \"mandatory → blocking_gate\" | \"recommended → review_warning\" | \"contextual → context_required\" | \"discouraged → exception_required\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Anti-Pattern Rule Compiler](/records/algorithms/anti-pattern-rule-compiler), [Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation)", "term": "Composed by" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every finding treated the same — a style nit blocks like a critical flaw.", "kind": "code", "language": "text", "title": "Before" }, { "code": "severity{mandatory} → blocking-gate ; severity{recommended} → review-warning ; severity{contextual} → context-required", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-severity-policy", "title": "Severity Policy" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For each concept applicable to the current scope, execute its detected_by signals against the implementation, map observations to violated_by patterns, and produce evidence-backed violation records.", "term": "Intent" }, { "description": "A principle violation must be grounded in observable implementation signals.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ApplicableConcept → DetectionSignals → Observations → ViolationRecords", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ViolationDetection ::= \"→\" \"→\" \"→\" \nViolationRecord ::= \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[observability_traceability](/records/force/observability-traceability), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Foo is violated' asserted from opinion, with no observable signal.", "kind": "code", "language": "text", "title": "Before" }, { "code": "concept{Foo} → detected_by signals run on code → observations → violation-record{concept, pattern, evidence, severity}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-violation-detection", "title": "Violation Detection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "Convert each concept’s measured_by field into executable or reviewable metrics, collect metric values, normalize them to comparable scores, and attach confidence based on measurement quality.", "term": "Intent" }, { "description": "Architectural assessment requires metrics with provenance, not free-form judgment.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MeasuredBy → MetricDefinition → Measurement → NormalizedScore → Confidence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MeasurementNormalization ::= \"→\" \"→\" \"→\" \nMetricDefinition ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Architecture judged by free-form opinion, no comparable numbers.", "kind": "code", "language": "text", "title": "Before" }, { "code": "measured_by{coupling} → metric-definition{scope, method, threshold} → values → normalized score + confidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-measurement-normalization", "title": "Measurement Normalization" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a violation record, select refactor actions from the concept’s refactored_by field, rank actions by severity, dependency closure, blast radius, and expected reinforcement gain.", "term": "Intent" }, { "description": "Refactoring should be selected from the violated concept’s remediation contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Violation → RefactorCandidates → RiskRank → SelectedPlan", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RefactorSelection ::= \"→\" \"→\" \"→\" \nRefactorRanking ::= \"severity\" \",\" \"required_dependency_count\" \",\" \"blast_radius\" \",\" \"reinforcement_gain\" \",\" \"rollback_feasibility\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A fix chosen ad hoc, unrelated to the violated concept's remediation contract.", "kind": "code", "language": "text", "title": "Before" }, { "code": "violation{Foo} → refactored_by candidates → rank{severity, blast-radius, reinforcement-gain} → refactor plan", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-refactor-selection", "title": "Refactor Selection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Translate each concept’s enforced_by field into static checks, contract tests, schema validation, CI gates, policy rules, runtime monitors, review gates, or architecture fitness functions.", "term": "Intent" }, { "description": "Enforcement converts architectural intent into repeatable control.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EnforcementDescriptor → GateType → ValidationProcedure → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EnforcementGate ::= \"→\" \"→\" \"→\" \nGateType ::= \"static_analysis\" | \"architecture_test\" | \"schema_validation\" | \"contract_test\" | \"lint_rule\" | \"fitness_function\" | \"runtime_monitor\" | \"policy_as_code\" | \"review_gate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'enforced_by: review' — a reviewer's promise that erodes under deadline.", "kind": "code", "language": "text", "title": "Before" }, { "code": "enforced_by{Foo} → gate-type{static-analysis | contract-test | fitness-function} → pass/fail in CI", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-enforcement-gate", "title": "Enforcement Gate" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select concepts relevant to a target scope, compute dependency closure, detect violations, measure evidence, rank findings by severity, and emit a prioritized architecture assessment.", "term": "Intent" }, { "description": "Assessment is graph query plus evidence collection plus severity policy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Scope → RelevantConcepts → DependencyClosure → Detection → Measurement → Findings", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureAssessment ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nFindingPrioritization ::= \"mandatory_first\" \",\" \"high_blast_radius\" \",\" \"high_reinforcement_gain\" \",\" \"low_refactor_cost\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization)", "term": "Composes" }, { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'The architecture is fine' — an unscoped, evidence-free claim.", "kind": "code", "language": "text", "title": "Before" }, { "code": "scope → relevant concepts → dependency-closure → violation-detection → measurement → prioritized findings", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-assessment", "title": "Architecture Assessment" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Evaluate SRP, separation of concerns, cohesion, coupling, encapsulation, information hiding, abstraction, modularity, composability, replaceability, and autonomy as a connected boundary cluster.", "term": "Intent" }, { "description": "Modular design is not one principle; it is a mutually reinforcing cluster around responsibility, dependency, and visibility.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Module → Responsibility → Cohesion → Coupling → Visibility → BoundaryHealth", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModularBoundaryCompliance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nBoundaryScore ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Modularity judged as one vague impression.", "kind": "code", "language": "text", "title": "Before" }, { "code": "modules → responsibility + cohesion + coupling + visibility-leak → boundary score{per-dimension}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-modular-boundary-compliance", "title": "Modular Boundary Compliance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For APIs, services, data, schemas, and protocols, validate explicit contracts, preconditions, postconditions, invariants, versioning, backward compatibility, forward compatibility, and interoperability.", "term": "Intent" }, { "description": "Compatibility is the contract cluster that allows independent evolution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Boundary → Contract → Version → CompatibilityMatrix → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContractCompatibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nCompatibilityMatrix ::= \"producer_current_consumer_current\" | \"producer_new_consumer_old\" | \"producer_old_consumer_new\" | \"unknown_field_handling\" | \"breaking_diff_check\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A schema changed and downstreams broke — compatibility was never checked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "boundary-contract → schema/semantic validation → version-policy → compatibility-matrix{new-producer/old-consumer} → verdict", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-contract-compatibility", "title": "Contract Compatibility" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect duplicated or conflicting models, schemas, terms, rules, and data definitions; select or create canonical authority; normalize variants; enforce single source of truth.", "term": "Intent" }, { "description": "Semantic consistency requires canonical authority and explicit translation where contexts differ.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Concepts → Conflicts → CanonicalAuthority → Normalization → Enforcement", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CanonicalSemantics ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSemanticArtifact ::= \"schema\" | \"domain_model\" | \"field\" | \"term\" | \"rule\" | \"configuration\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Three models of 'Foo' drift apart; no single authority.", "kind": "code", "language": "text", "title": "Before" }, { "code": "artifacts{Foo-a, Foo-b} → conflict-detection → canonical authority → normalize variants → SSOT gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-canonical-semantics", "title": "Canonical Semantics" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Require components, services, APIs, plugins, and runtime structures to declare metadata, capabilities, contracts, dependencies, configuration, and health so they can be discovered and validated.", "term": "Intent" }, { "description": "Dynamic architecture requires self-description before runtime binding.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Component → Manifest → CapabilityDeclaration → Discovery → ContractValidation → Binding", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SelfDescribingDiscovery ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nManifest ::= \"identity\" \",\" \"version\" \",\" \"capabilities\" \",\" \"dependencies\" \",\" \"contracts\" \",\" \"configuration\" \",\" \"health\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A runtime component's capabilities are unknowable without reading its source.", "kind": "code", "language": "text", "title": "Before" }, { "code": "entity → manifest{identity, capabilities, contracts} → discovery → conformance-validation → bind only if it matches", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-self-description-and-discovery", "title": "Self-Description and Discovery" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect repeated core modification for variants, define extension points, create plugin contracts, register implementations, discover them dynamically, and isolate failures.", "term": "Intent" }, { "description": "Extensibility is controlled variation behind stable runtime contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "VariantPressure → ExtensionPoint → PluginContract → Registry → Discovery → Isolation", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RuntimeExtensibility ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRegistrationPolicy ::= \"manual_registration\" | \"manifest_based\" | \"service_registry\" | \"convention_based\" | \"configuration_based\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Runtime Discovery](/records/algorithms/runtime-discovery)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "[Runtime Extensibility](/records/architecture/runtime-extensibility)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Every new variant edits the core switch statement.", "kind": "code", "language": "text", "title": "Before" }, { "code": "variant-pressure → extension-point → plugin-contract → registry → runtime-discovery → failure-isolation", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Runtime Discovery](/records/algorithms/runtime-discovery)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-runtime-extensibility", "title": "Runtime Extensibility" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Select creational, structural, or behavioral patterns based on the problem force: creation variation, interface mismatch, access control, behavior variation, notification, workflow reuse, or coordination complexity.", "term": "Intent" }, { "description": "Design patterns are remedies for specific force shapes, not generic decorations.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProblemForce → PatternFamily → CandidatePattern → ApplicabilityCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternSelection ::= \"→\" \"→\" \"→\" \nPatternFamily ::= \"creational\" | \"structural\" | \"behavioral\"\nCandidatePattern ::= \"factory\" | \"factory_method\" | \"abstract_factory\" | \"builder\" | \"prototype\" | \"adapter\" | \"facade\" | \"proxy\" | \"bridge\" | \"decorator\" | \"strategy\" | \"template_method\" | \"observer\" | \"mediator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pattern applied as decoration ('let's add a Facade') with no force to justify it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "force{interface mismatch} → family{structural} → candidate{Adapter} → applicability verdict", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-selection", "title": "Pattern Selection" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For asynchronous systems, validate event contracts, message schemas, idempotent consumers, outbox publication, correlation metadata, ordering guarantees, retry behavior, and dead-letter handling.", "term": "Intent" }, { "description": "Event-driven architecture is safe only when messages are contracts and consumers are replay-safe.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StateChange → EventContract → Outbox → Broker → IdempotentConsumer → Trace", "kind": "code", "language": "text", "title": "Flow" }, { "code": "EventMessagingConsistency ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nEventClassification ::= \"domain_event\" | \"integration_event\" | \"stream_event\"\nPublicationReliability ::= \"transactional_outbox\" | \"append_only_log\" | \"broker_acknowledgement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Observability Trace](/records/algorithms/observability-trace)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [observability_traceability](/records/force/observability-traceability), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[Event Messaging](/records/algorithms/event-messaging): Event messaging describes how state changes are published and consumed; this record validates that the published messages are contracts and that consumers are safe to replay.", "term": "Distinct from" } ], "kind": "glossary" }, { "code": "Events published ad hoc; a consumer replays and double-applies.", "kind": "code", "language": "text", "title": "Before" }, { "code": "state-change → event-contract → transactional-outbox → broker → idempotent-consumer → ordering + trace", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Observability Trace](/records/algorithms/observability-trace)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-event-and-messaging-consistency", "title": "Event and Messaging Consistency" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Identify state mutation boundaries, enforce unit-of-work scope, validate invariants, apply concurrency control, guarantee idempotency where retries exist, and isolate side effects.", "term": "Intent" }, { "description": "State correctness depends on explicit mutation boundaries and repeat-safe effects.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Command → TransactionBoundary → Invariant → Concurrency → Commit|Rollback → Idempotency", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StateTransactionSafety ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nConcurrencyControl ::= \"optimistic_locking\" | \"pessimistic_locking\" | \"serial_execution\" | \"state_isolation\"\nSideEffectPolicy ::= \"idempotent\" | \"outbox_published\" | \"compensatable\" | \"controlled_side_effect\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Two mutations with no boundary; a crash between them corrupts state.", "kind": "code", "language": "text", "title": "Before" }, { "code": "command → transaction-boundary → invariant-check → concurrency-control → commit/rollback → idempotent side-effect", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Transaction Boundary](/records/algorithms/transaction-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-state-and-transaction-safety", "title": "State and Transaction Safety" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Push nondeterminism to boundaries, prefer pure deterministic core logic, validate specifications with static analysis, type checks, property tests, contract tests, formal methods where useful, and reproducible test environments.", "term": "Intent" }, { "description": "Correctness is achieved by deterministic design plus evidence-based verification.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Input → Canonicalize → DeterministicCore → Spec → Verification → Evidence", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CorrectnessVerification ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nVerificationMethod ::= \"type_check\" | \"static_analysis\" | \"schema_validation\" | \"contract_test\" | \"property_based_test\" | \"specification_test\" | \"formal_verification\" | \"runtime_validation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Correctness asserted by 'it worked on my machine'.", "kind": "code", "language": "text", "title": "Before" }, { "code": "input → canonicalize → deterministic-core → spec → {type-check, property-test, contract-test} → evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-correctness-verification", "title": "Correctness Verification" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Classify failure modes, apply fail-fast, fail-safe, fail-secure, retry, timeout, circuit breaker, fallback, bulkhead, backpressure, health check, failover, and rollback policies according to dependency criticality.", "term": "Intent" }, { "description": "Resilience is controlled degradation under known failure modes.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FailureMode → Criticality → PolicySet → RuntimeGuard → Recovery", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResiliencePolicy ::= \"→\" \"→\" \"→\" \"→\" \nResiliencePattern ::= \"timeout\" | \"retry\" | \"circuit_breaker\" | \"fallback\" | \"bulkhead\" | \"backpressure\" | \"health_check\" | \"failover\" | \"rollback\" | \"auto_remediation\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A remote call with no failure policy takes the whole system down.", "kind": "code", "language": "text", "title": "Before" }, { "code": "failure-modes → criticality → {timeout, retry, circuit-breaker, bulkhead} → runtime-guard → recovery", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-resilience-policy", "title": "Resilience Policy" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Attach correlation and causation identifiers, emit logs, metrics, traces, alerts, audit records, and runtime health signals, then reconstruct behavior as a causal execution graph.", "term": "Intent" }, { "description": "Operability requires reconstructable evidence across runtime boundaries.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Operation → Correlation → Telemetry → Audit → TraceGraph → Diagnosis", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ObservabilityAuditability ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTelemetryEvent ::= \"structured_log\" | \"metric\" | \"trace_span\" | \"alert\" | \"audit_log\" | \"health_signal\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [observability_traceability](/records/force/observability-traceability), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An incident with no correlation ids — behavior can't be reconstructed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "operation → correlation-id + causation-id → {logs, metrics, traces, audit} → trace-graph → diagnosis", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-observability-and-auditability", "title": "Observability and Auditability" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Establish workload model, profile runtime behavior, benchmark repeatably, identify bottlenecks, analyze time and space complexity, select scaling strategy, optimize only measured bottlenecks, and enforce SLO gates.", "term": "Intent" }, { "description": "Performance engineering is evidence-driven bottleneck control, not speculative optimization.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workload → Profile → Benchmark → Bottleneck → Complexity → Scale|Optimize → SLO", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PerformanceScalability ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nScalingOrOptimizationPlan ::= \"vertical_scale\" | \"horizontal_scale\" | \"load_balance\" | \"shard\" | \"partition\" | \"cache\" | \"stream\" | \"rate_limit\" | \"algorithm_replacement\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[performance_scaling](/records/force/performance-scaling), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Optimize by guesswork; add capacity and hope.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workload → profile → benchmark → bottleneck → complexity → scale/optimize the measured bottleneck → SLO gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-performance-and-scalability", "title": "Performance and Scalability" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Threat-model the system, reduce attack surface, authenticate identity, authorize actions, validate input, encode output, encrypt data, manage secrets, enforce policy as code, and continuously audit compliance.", "term": "Intent" }, { "description": "Security is an enforced policy graph over identity, data, operations, and infrastructure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ThreatModel → ControlSet → Policy → Enforcement → Audit", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SecurityGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSecurityControl ::= \"authentication\" | \"authorization\" | \"least_privilege\" | \"zero_trust\" | \"input_validation\" | \"output_encoding\" | \"encryption_at_rest\" | \"encryption_in_transit\" | \"secrets_management\" | \"audit_logging\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Security added as a late checklist, not a policy graph.", "kind": "code", "language": "text", "title": "Before" }, { "code": "threat-model → controls{authn, authz, validation, encryption, secrets} → policy-as-code → enforcement → continuous audit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-security-governance", "title": "Security Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Assess architecture against quality attributes, record decisions, analyze impact, track gaps, enforce standards with fitness functions, standardize patterns, and evolve through ADR-backed controlled change.", "term": "Intent" }, { "description": "Evolutionary architecture requires decision memory and continuous fitness validation.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Assessment → GapAnalysis → DecisionRecord → FitnessFunction → ChangePlan → Review", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureEvolutionGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nDecisionRecord ::= \"ADR\" \",\" \"context\" \",\" \"decision\" \",\" \"consequences\" \",\" \"status\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment)", "term": "Composes" }, { "description": "[Architectural Relationship Algebra](/records/algorithms/architectural-relationship-algebra), [Version Provenance](/records/algorithms/version-provenance), [Type-Migration Centralization](/records/algorithms/type-migration-centralization)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Architecture drifts; no decision memory, no fitness checks.", "kind": "code", "language": "text", "title": "Before" }, { "code": "assessment → gap-analysis → ADR → fitness-functions → change-plan → review gate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Architecture Assessment](/records/algorithms/architecture-assessment)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-evolution-governance", "title": "Architecture Evolution Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Separate control-plane policy from data-plane execution, centralize configuration, authentication, logging, or orchestration only where shared governance is beneficial, and preserve local autonomy where decentralization is required.", "term": "Intent" }, { "description": "Control centralization should govern policy without collapsing execution autonomy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → ControlPlane → DataPlane → Telemetry → PolicyAdjustment", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ControlPlaneCoordination ::= \"→\" \"→\" \"→\" \"→\" \nControlConcern ::= \"configuration\" | \"authentication\" | \"authorization\" | \"logging\" | \"orchestration\" | \"service_registry\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Control Plane](/records/algorithms/control-plane)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[Control Plane](/records/algorithms/control-plane): The control plane is the mechanism that coordinates policy; this record composes it and decides which concerns are centralized and which stay local.", "term": "Distinct from" } ], "kind": "glossary" }, { "code": "Every service does its own config + auth; policy scatters and drifts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "policy → control-plane{config, authn, orchestration} → data-planes execute → telemetry → governance adjustment", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Control Plane](/records/algorithms/control-plane)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-control-plane-coordination", "title": "Control Plane Coordination" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Treat code as data only through schemas, manifests, DSL grammars, reflection contracts, compile-time checks, runtime guards, and generated artifact validation.", "term": "Intent" }, { "description": "Metaprogramming is safe when generated behavior is bounded by a validated model.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Model → Schema → Transform → Generate|Interpret → Validate → Execute", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MetaprogrammingSafety ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTransformationEngine ::= \"reflection\" | \"introspection\" | \"compile_time_evaluation\" | \"runtime_code_generation\" | \"DSL_interpreter\" | \"model_driven_generator\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Code-as-string eval'd with no schema or bound.", "kind": "code", "language": "text", "title": "Before" }, { "code": "model → schema → transform{reflection | DSL} → generated artifact → safety-validation → bounded execution", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-metaprogramming-safety", "title": "Metaprogramming Safety" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Register and version models, prompts, datasets, embeddings, retrieval sources and knowledge graphs, evaluate behavior against benchmarks, validate safety constraints, trace inference inputs through an inference contract, and monitor drift after deployment.", "term": "Intent" }, { "description": "Model-backed architecture requires governance over evidence, model behavior, inference, evaluation, and safety.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ModelArtifact → Registry → Evaluation → Safety → InferenceTrace → Monitoring", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModelLifecycleGovernance ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nModelArtifact ::= \"model\" | \"prompt\" | \"embedding_index\" | \"retrieval_source\" | \"knowledge_graph\" | \"dataset\" | \"evaluation\"\nInferenceContract ::= \"input_schema\" \",\" \"retrieval_context\" \",\" \"model_version\" \",\" \"output_schema\" \",\" \"explanation_or_trace\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A model shipped with no registry, eval, trace, or safety gate.", "kind": "code", "language": "text", "title": "Before" }, { "code": "artifacts{model, prompt, index} → governance-registry → evaluation → inference-contract → explainability-trace → safety + monitoring", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-model-lifecycle-governance", "title": "Model Lifecycle Governance" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Given a target problem, query the graph for matching violated_by and detected_by signals, collect candidate concepts, compute required dependencies, remove conflicting concepts, rank by severity and reinforcement gain, then recommend an ordered implementation path.", "term": "Intent" }, { "description": "Recommendations are graph-derived paths from evidence to enforceable architecture change.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProblemEvidence → CandidateConcepts → DependencyClosure → ConflictPrune → Rank → Roadmap", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitecturalRecommendation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSeverityRanking ::= \"mandatory_before_recommended\" \",\" \"contextual_when_scope_matches\" \",\" \"discouraged_requires_exception\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Dependency Closure](/records/algorithms/dependency-closure)", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Advice given from intuition, not from the graph or the evidence.", "kind": "code", "language": "text", "title": "Before" }, { "code": "problem-evidence → concept-match → dependency-closure → conflict-prune → severity rank → ordered roadmap", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Dependency Closure](/records/algorithms/dependency-closure)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architectural-recommendation", "title": "Architectural Recommendation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Convert mandatory and high-impact recommended records into executable fitness functions by binding detected_by signals to checks, measured_by fields to thresholds, and enforced_by fields to pipeline gates.", "term": "Intent" }, { "description": "The catalog becomes self-enforcing when records compile into fitness functions.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RelationshipRecord → DetectionCheck → MetricThreshold → EnforcementGate → FitnessFunction", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FitnessFunctionGeneration ::= \"→\" \"→\" \"→\" \"→\" \nFitnessFunction ::= \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Enforcement Gate](/records/algorithms/enforcement-gate), [Severity Policy](/records/algorithms/severity-policy)", "term": "Composes" }, { "description": "[streaming_dataflow](/records/force/streaming-dataflow), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Mandatory records sit as prose no check executes.", "kind": "code", "language": "text", "title": "Before" }, { "code": "record → detection-check + metric-threshold + enforcement-gate → executable fitness function", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Enforcement Gate](/records/algorithms/enforcement-gate), [Severity Policy](/records/algorithms/severity-policy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-fitness-function-generation", "title": "Architecture Fitness Function Generation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Group violations by shared refactor actions, order remediation by prerequisite concepts, apply low-risk structural fixes first, then enforce newly satisfied concepts through gates.", "term": "Intent" }, { "description": "Architecture repair is more efficient when refactors are grouped by shared conceptual cause.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Violations → SharedCause → RefactorGroup → DependencyOrder → Apply → Enforce", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RefactoringRoadmap ::= \"→\" \"→\" \"→\" \"→\" \nSharedCause ::= \"missing_boundary\" | \"missing_contract\" | \"semantic_drift\" | \"concrete_coupling\" | \"uncontrolled_state\" | \"missing_observability\" | \"manual_governance_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Violations fixed one-by-one in random order; shared causes re-fixed repeatedly.", "kind": "code", "language": "text", "title": "Before" }, { "code": "violations → cluster by shared-cause{missing-boundary} → refactor-groups → dependency-ordered plan → enforce", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-refactoring-roadmap", "title": "Architecture Refactoring Roadmap" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Group concepts into clusters by mutual requires, reinforces, enables, and shared scope; treat clusters as higher-order architectural concerns.", "term": "Intent" }, { "description": "Large principle catalogs become usable when concepts are clustered by relationship density.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Graph → EdgeDensity → Cluster → ConcernFamily", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConceptClusterExtraction ::= \"→\" \"→\" \"→\" \nConcernFamily ::= \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A flat catalog of hundreds of concepts, unusable at scale.", "kind": "code", "language": "text", "title": "Before" }, { "code": "graph → relationship-density analysis → clusters → concern-families{core + supporting + conflict concepts}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concept-cluster-extraction", "title": "Concept Cluster Extraction" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "For each proposed design decision, compute satisfied concepts, violated concepts, tensions introduced, conflicts triggered, enabled capabilities, and enforcement cost; require ADR when trade-offs are nontrivial.", "term": "Intent" }, { "description": "A design decision should be evaluated as a graph delta.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Decision → GraphDelta → BenefitSet + RiskSet → ADRRequired?", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureDecisionSupport ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nDecisionGovernance ::= \"approve\" | \"approve_with_ADR\" | \"revise\" | \"reject\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A design decision judged by gut feel, not by its effect on the graph.", "kind": "code", "language": "text", "title": "Before" }, { "code": "decision → graph-delta{satisfied, violated, tensions, enabled} → enforcement-cost → approve / approve-with-ADR / revise / reject", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-decision-support", "title": "Architecture Decision Support" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate every concept record for required fields, known relation names, parseable scope, valid severity, nonempty detection and enforcement metadata, and resolvable references where possible.", "term": "Intent" }, { "description": "The architectural catalog itself must be governed as a schema-bearing artifact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Record → SchemaCheck → ReferenceCheck → CompletenessCheck → Valid|Invalid", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RelationshipSchemaValidation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nRequiredFieldSet ::= \"type\" \",\" \"scope\" \",\" \"requires\" \",\" \"reinforces\" \",\" \"enables\" \",\" \"conflicts_with\" \",\" \"tensions_with\" \",\" \"violated_by\" \",\" \"detected_by\" \",\" \"measured_by\" \",\" \"refactored_by\" \",\" \"enforced_by\" \",\" \"severity\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Catalog records with missing fields and dangling references ship unchecked.", "kind": "code", "language": "text", "title": "Before" }, { "code": "records → required-field validation → reference-resolution → severity validation → completeness score → catalog validity", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-relationship-schema-validation", "title": "Relationship Schema Validation" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compile the relationship catalog into four executable artifacts: assessment rules, refactor playbooks, decision-support graphs, and governance gates.", "term": "Intent" }, { "description": "A comprehensive architecture catalog should compile into operational tooling.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Catalog → Rules + Playbooks + DecisionGraph + Gates", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ArchitectureCatalogCompiler ::= \"→\" \"→\" \"→\" \"→\" \nAssessmentRule ::= \",\" \",\" \",\" \nRefactorPlaybook ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The catalog read only by the developer — no operational output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "graph → {assessment-rules, refactor-playbooks, decision-support-model, governance-gates}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-architecture-catalog-compiler", "title": "Architecture Catalog Compiler" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Parse the catalog, validate records, build the graph, classify target scope, select relevant concept clusters, compute dependency closure, detect violations, measure evidence, resolve conflicts, generate refactor plans, enforce gates, and record decisions.", "term": "Intent" }, { "description": "The catalog can be executed as a governance kernel for architecture assessment, remediation, and evolution.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Catalog → Graph → Scope → Concepts → Detection → Metrics → Refactor → Enforcement → ADR", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MasterArchitectureGovernanceKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nGovernanceReport ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization), [Refactor Selection](/records/algorithms/refactor-selection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Architecture Decision Support](/records/algorithms/architecture-decision-support)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Assessment, remediation, and evolution done by disconnected manual steps.", "kind": "code", "language": "text", "title": "Before" }, { "code": "validate → graph → scope → clusters → closure → detect → measure → resolve → refactor → enforce → ADR → governance report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which validates every relationship record's fields, relations and references", "term": "Checked by" }, { "description": "Every architecture record in the catalog", "term": "Population" }, { "description": "A verdict stands until a record or the relation ranges change", "term": "Freshness" }, { "description": "The gate fails on a dangling edge, an out-of-range relation, an unknown severity or an empty required field", "term": "Refusal" }, { "description": "None, because the catalog is data; the checks its records name observe the systems", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unchecked principle, a blank required field, a severity outside the closed levels and a definition that opens as another kind, and the bundled records pass", "term": "Evidence" }, { "description": "The relation ranges and the closed field vocabularies, which every record conforms to", "term": "Authoritative side" }, { "description": "[Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Dependency Closure](/records/algorithms/dependency-closure), [Violation Detection](/records/algorithms/violation-detection), [Measurement Normalization](/records/algorithms/measurement-normalization), [Refactor Selection](/records/algorithms/refactor-selection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Architecture Decision Support](/records/algorithms/architecture-decision-support)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-master-architecture-governance-kernel", "title": "Master Architecture Governance Kernel" }, { "blocks": [ { "items": [ "Domain: [arch-relationships](/records/algorithms-domain/arch-relationships)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → ", "term": "Intent" }, { "description": "Coverage is complete when every (dimension x lens) surface the unit can fail in carries a surface, a technique, and an invariant with a non-unknown verdict.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SurfaceSpace → GridWalk → RequiredGaps → Priority → TechniqueInvariant → AuthoredTest → Verdict → Ledger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TestCoverageConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the evidence verdict, which is pass or fail only against a non-empty evidence set, the covered-surfaces check on each module's declaration", "term": "Checked by" }, { "description": "Every surface the unit can fail in", "term": "Population" }, { "description": "A verdict stands until the unit's code or its tests change", "term": "Freshness" }, { "description": "A required surface with no evidence stays unknown, and completion is refused while any required surface is unknown", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces' lists, which locate failures without certifying their absence", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The evidence set, which a verdict is decided from, so a required surface without evidence stays unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-test-coverage-concern", "title": "" } ], "title": "Test coverage" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_pag_document_declaration[\"PAG Document Declaration\"]\n n_pag_keyword_ontology[\"PAG Keyword Ontology\"]\n n_pag_node_decomposition[\"PAG Node Decomposition\"]\n n_pag_validation_gate[\"PAG Handoff Gate\"]\n n_pag_explicit_control_flow[\"PAG Explicit Control Flow\"]\n n_pag_constraint_boundary[\"PAG Invariant Record\"]\n n_pag_tool_invocation[\"PAG Semantic Operation\"]\n n_pag_coordination_construct[\"PAG Structure Declaration\"]\n n_pag_ambiguity_reduction[\"PAG Ambiguity Reduction\"]\n n_pag_authoring_kernel[\"PAG Authoring Kernel\"]\n n_pag_well_formedness_validation[\"PAG Well-Formedness Validation\"]\n n_pag_instruction_concern[\"\"]\n n_pag_authoring_kernel --> n_pag_document_declaration\n n_pag_authoring_kernel --> n_pag_keyword_ontology\n n_pag_authoring_kernel --> n_pag_node_decomposition\n n_pag_authoring_kernel --> n_pag_validation_gate\n n_pag_authoring_kernel --> n_pag_explicit_control_flow\n n_pag_authoring_kernel --> n_pag_tool_invocation\n n_pag_authoring_kernel --> n_pag_coordination_construct\n n_pag_authoring_kernel --> n_pag_constraint_boundary\n n_pag_authoring_kernel --> n_pag_well_formedness_validation\n n_pag_well_formedness_validation --> n_pag_validation_gate\n n_pag_well_formedness_validation --> n_pag_explicit_control_flow" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-pag", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Bind a document to a declared type and its default verb (THIS ) after the YAML frontmatter and before any node, then declare in the meta block what the document is for, which sources ground which, what it trusts, what it may touch and what it declares outside itself, and how far repair may recurse.", "term": "Intent" }, { "description": "A PAG document announces what kind of instruction it is, and what it may touch, before it instructs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Frontmatter → TypeDeclaration → DefaultVerb → MetaBlock → Jurisdiction → DeclaredContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagDocumentDeclaration ::= \"→\" \"→\" \"→\" \nPagDocumentType ::= \"AGENT\" | \"WORKFLOW\" | \"PROTOCOL\" | \"POLICY\" | \"CHECKLIST\" | \"TEMPLATE\" | \"TASK\" | \"INSTRUCTION\" | \"PROMPT\" | \"COMMAND\" | \"TEST\" | \"DEBUG\" | \"VERIFICATION\" | \"DISTILLATION\" | \"AUDIT\" | \"TRANSLATION\" | \"COMPOSITION\"\nPagDocumentVerb ::= \"IS\" | \"ENFORCES\" | \"EXECUTES\" | \"PERFORMS\" | \"PROVIDES\" | \"IMPLEMENTS\" | \"DEFINES\" | \"MANAGES\" | \"COORDINATES\" | \"HAS\" | \"GENERATES\" | \"RESOLVES\" | \"FINDS\" | \"FIXES\" | \"VERIFIES\" | \"CLASSIFIES\" | \"DISTILLS\" | \"ABSTRACTS\" | \"ELIMINATES\" | \"AUDITS\" | \"MEASURES\" | \"SCORES\" | \"CORRECTS\" | \"RENDERS\" | \"COMPOSES\" | \"FOLDS\"\nPagMetaField ::= \"objective\" | \"priority\" | \"trust\" | \"jurisdiction\" | \"recursion_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility), [metaprogramming_modeling](/records/force/metaprogramming-modeling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A document instructs with no declared type — its semantic contract, its authority and its jurisdiction are implicit.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frontmatter → THIS {AGENT|WORKFLOW|CHECKLIST} {IS|EXECUTES|ENFORCES} description → META block{objective, priority, trust, jurisdiction, recursion_limit} → declared contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-document-declaration", "title": "PAG Document Declaration" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Draw every operative token from a fixed, uppercase, code-frequent vocabulary partitioned into semantic categories, each token grounded to a record in the reasoning ontology, and bind targets to sources through explicit prepositions, so the model completes recognized structured patterns rather than interpreting prose.", "term": "Intent" }, { "description": "Explicit high-frequency uppercase tokens, each grounded to a reasoning record, reduce interpretive variance; prose does not.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProseIntent → KeywordCategory → UppercaseToken → ReasoningGround → PrepositionBinding → StructuredDirective", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagKeywordOntology ::= \"→\" \"→\" \"→\" \"→\" \nPagKeywordCategory ::= \"semantic_operation\" | \"node\" | \"action\" | \"control_flow\" | \"declaration\" | \"modifier\" | \"coordination\" | \"state_machine\" | \"dag\" | \"priority_queue\" | \"flowchart\" | \"document_type\" | \"document_verb\" | \"meta\" | \"validation\" | \"report\" | \"invariant\" | \"contextual\"\nPagPreposition ::= \"FROM\" | \"TO\" | \"INTO\" | \"WITH\" | \"USING\" | \"AGAINST\" | \"IN\" | \"AS\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Get the data and check it' — prose the model must interpret.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prose intent → uppercase token{READ_RESOURCE|ANALYZE_CONTENT|VALIDATE_ARTIFACT} + preposition{FROM|INTO|AGAINST} → structured directive, low interpretive variance", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-keyword-ontology", "title": "PAG Keyword Ontology" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Group directives into nodes, each one decision on one reasoning axis, headed by its layer, axis, math type and the shape its decision yields, tagged with the substrate stage its artifact comes to be at, and contracted so that its input names the prior node's output or a declared slot, its transform is stated in semantic operations, and its output is the one record the next node reads.", "term": "Intent" }, { "description": "Each node is one bounded decision whose data flow from the prior node is declared by identity, never inferred from a name.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DirectiveSet → NodeHeader → GenesisStage → Contract → DeclaredInput → NodeOutput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagNodeDecomposition ::= \"→\" \"→\" \nPagNodeHeader ::= \"#\" \"NODE\" \"—\" \"[\" \"·\" \"·\" \"·\" \"yields:\" \"]\"\nPagNodeContract ::= \"CONTRACT:\" \"input:\" \"transform:\" \"output:\" \nPagScopeRule ::= \"declare_before_use\" \",\" \"document_wide_scope\" \",\" \"prior_output_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [domain_boundary](/records/force/domain-boundary), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Directives poured in one flat block, forward-referencing later work, with no statement of what each block decides or what shape its decision takes.", "kind": "code", "language": "text", "title": "Before" }, { "code": "directives → nodes{# NODE n — NAME [layer · axis · math type · yields: shape], @genesis, CONTRACT input/transform/output, one gate} → a node reads only the prior node's output → explicit data flow", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-node-decomposition", "title": "PAG Node Decomposition" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Close every node with a handoff gate of three-to-five checks, each a claim about the output with the evidence that settles it and the population it was measured over, a refusal condition named before any irreversible write, the standing of the read set beside the verdict, and a result line that routes pass to the next node, each failure to the earliest node that owns its repair, and unknown to blocked.", "term": "Intent" }, { "description": "A node boundary is trusted only when its checks carry evidence and a population, its writes are refused before they land, and its unknown is routed; unknown is not pass.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "NodeOutput → CheckWithEvidence → Population → Refusal → Standing → ThreeVerdicts → ResultLine", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagHandoffGate ::= \"→\" \"→\" \"→\" \"→\" \nPagCheckLine ::= \"[check]\" \"(evidence:\" \")\" \"over:\" \"measured:\" \"/\" \nPagVerdict ::= \"pass\" | \"fail\" | \"unknown\"\nPagResultLine ::= \"result:\" \"pass\" \"→\" \"|\" \"→\" \"REPAIR\" \"(owner:\" \")\" \"|\" \"unknown\" \"→\" \"BLOCKED\"\nPagGateConstraint ::= \"evidence_per_check\" \",\" \"population_declared\" \",\" \"three_to_five_checks\" \",\" \"refusal_before_write\" \",\" \"unknown_routed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence), [ver-population](/records/reasoning/node-ver-population), [ver-refusal](/records/reasoning/node-ver-refusal), [ver-standing](/records/reasoning/node-ver-standing), [ter-block](/records/reasoning/node-ter-block)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A node ends with 'looks good' — a vague assertion with no evidence, no population, no refusal, and only two verdicts.", "kind": "code", "language": "text", "title": "Before" }, { "code": "node output → 3-5 checks{[check] claim (evidence: what settles it) over: set measured: n / N} + refuse: condition before write + standing: moved-set + result: pass → next | failure → REPAIR (owner) | unknown → BLOCKED", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-validation-gate", "title": "PAG Handoff Gate" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Express branching with IF / ELSE IF / ELSE, iteration with FOR EACH over a collection (never a bare FOR), and failure handling with TRY / CATCH, every conditional colon-terminated and every branch a complete directive sequence.", "term": "Intent" }, { "description": "Control flow is explicit and colon-delimited so the model does not infer structure from prose sequence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Condition → BranchSet → IterationForm → FailureForm → DeterministicPath", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagControlFlow ::= | | \nPagIteration ::= \"FOR\" \"EACH\" \"IN\" \":\" \nPagControlConstraint ::= \"colon_terminated\" \",\" \"for_each_not_for\" \",\" \"complete_branch_directives\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "Composed by" }, { "description": "[correctness_verification](/records/force/correctness-verification), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Branching and iteration inferred from prose order; a bare FOR, a missing colon.", "kind": "code", "language": "text", "title": "Before" }, { "code": "IF/ELSE IF/ELSE + FOR EACH x IN collection + TRY/CATCH → every conditional colon-terminated, complete branch directives", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-explicit-control-flow", "title": "PAG Explicit Control Flow" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "State every behavioral invariant as a record with four slots: the property in a form that could be false, the set it quantifies over, the parties it binds, and the objector, the check that would disagree if the property stopped holding or none as declared debt, so an unwatched invariant is visible rather than assumed.", "term": "Intent" }, { "description": "An invariant is stated with its property, its set, its parties and its objector, or it is indistinguishable from a property a reader happened to infer.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorPolicy → Property → Set → Parties → Objector → InvariantRecord", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagInvariantBlock ::= \"#\" \"CROSS-NODE\" \"INVARIANTS\" +\nPagInvariantRecord ::= \"INVARIANT\" \":\" \"over:\" \"binds:\" \"objector:\" ( | \"none\")\nPagInvariantQuality ::= \"falsifiable\" \",\" \"quantified\" \",\" \"delivered\" \",\" \"watched\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[model_governance](/records/force/model-governance), [security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Behavioral rules as a bullet list under ALWAYS and NEVER — no set the rule ranges over, no party it binds, nothing that would disagree if it stopped holding.", "kind": "code", "language": "text", "title": "Before" }, { "code": "INVARIANT name: property over: set binds: parties objector: check | none → each invariant stated in a form that could be false, with what watches it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-constraint-boundary", "title": "PAG Invariant Record" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Name every external effect as one of the semantic operations (discover, read, search, analyze, extract, calculate, compose, validate, persist, execute, request a decision, report) with a uniform WITH / USING parameter clause and an INTO / arrow result binding, so the document names what it does and an adapter binding resolves how, and no host's tool name enters the document.", "term": "Intent" }, { "description": "Every external effect is a semantic operation with explicit parameters and an explicit result binding, and the host's tools are the adapter's data.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticOperation → OperationTarget → ParameterClause → ResultBinding → AdapterBinding", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagToolInvocation ::= \nPagSemanticOperation ::= \"DISCOVER_RESOURCES\" | \"READ_RESOURCE\" | \"SEARCH_CONTENT\" | \"ANALYZE_CONTENT\" | \"EXTRACT_FACTS\" | \"CALCULATE_METRIC\" | \"COMPOSE_ARTIFACT\" | \"VALIDATE_ARTIFACT\" | \"PERSIST_ARTIFACT\" | \"EXECUTE_TOOL\" | \"REQUEST_DECISION\" | \"REPORT_RESULT\"\nPagResultBinding ::= \"INTO\" | \"→\" | \"AS\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An external effect described in prose, or named by one host's tool, so the document runs in one place only.", "kind": "code", "language": "text", "title": "Before" }, { "code": "semantic operation{READ_RESOURCE|PERSIST_ARTIFACT|EXECUTE_TOOL|REQUEST_DECISION} + WITH/USING params + INTO/→ result → a named effect the adapter binds to a host's tool", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-tool-invocation", "title": "PAG Semantic Operation" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Make a document's structure explicit with the declaration that names it: a DAG for a dependency graph, a STATE_MACHINE for a lifetime or a set of derived states, a PRIORITY_QUEUE for a ranking, a FLOWCHART for the rendered projection of a declared structure, and for a shared surface the coordination model's SURFACE, RECORD and ITEM with their typed edges, derived states and the one post-and-wait operation, so ordering, ownership and state are declared as structure rather than narrated as prose.", "term": "Intent" }, { "description": "Ordering, ownership and state are declared through explicit structure constructs a check can read, never implied by textual order.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructureNeed → StructureDeclaration → DeclaredEdges → DerivedState → ReadableStructure", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagStructure ::= | | | | \nPagStructureForm ::= \"DAG\" | \"STATE_MACHINE\" | \"PRIORITY_QUEUE\" | \"FLOWCHART\" | \"SURFACE\"\nPagSurface ::= \"SURFACE\" \":\" (\"RECORD\" \"subject:\" *)+\nPagEdgeKind ::= \"PARENT\" | \"SATISFIED_BY\" | \"BLOCKS\" | \"ANSWERS\" | \"REFUTES\" | \"SUPERSEDES\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Composed by" }, { "description": "[control_coordination](/records/force/control-coordination), [event_messaging](/records/force/event-messaging), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Concurrency, ordering, lifetimes and ownership implied by the order sentences appear in.", "kind": "code", "language": "text", "title": "Before" }, { "code": "a declared structure → DAG{dependency graph} | STATE_MACHINE{lifetime, derived states} | PRIORITY_QUEUE{ranking} | FLOWCHART{rendered projection} | SURFACE{RECORD, ITEM, typed edges, WAIT} → the structure is explicit and a check can read it", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-coordination-construct", "title": "PAG Structure Declaration" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Replace interpretive prose with explicit structured tokens so the model completes recognized patterns, while accepting that output stays probabilistic: the grammar reduces input ambiguity, it does not constrain output tokens or guarantee determinism.", "term": "Intent" }, { "description": "PAG shapes the input toward consistent completion and does not always apply; it reduces the variance of the output without making it deterministic.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProseAmbiguity → TokenStructure → PatternRecognition → ReducedVariance", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagAmbiguityReduction ::= \"→\" \"→\" \nPagApplicabilityBound ::= \"input_shaping_only\" \",\" \"probabilistic_output\" \",\" \"not_always_applicable\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Prose intent claimed to guarantee deterministic model output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "prose → structured tokens → reduced interpretation load; input-shaping only, output stays probabilistic (less variance, never deterministic)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-ambiguity-reduction", "title": "PAG Ambiguity Reduction" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose a PAG document as frontmatter and typed declaration, then a meta block with jurisdiction, then nodes each headed by its layer, axis, math type and yields, contracted to read the prior node's output, and closed by a handoff gate with evidence, population, refusal and the three verdicts, drawing directives from the semantic operations, control flow and structure declarations, and closing with invariant records and a report.", "term": "Intent" }, { "description": "A well-formed PAG document is a node-gated, keyword-typed, invariant-bounded instruction contract whose every verdict carries its population.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Declaration → MetaBlock → Nodes → Gates → Directives → Invariant → Report → PagDocument", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagAuthoringKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "Composes" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [model_governance](/records/force/model-governance), [contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Explicit Contracts](/records/architecture/explicit-contracts)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration)", "term": "orient" }, { "description": "[PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology)", "term": "see" }, { "description": "[PAG Node Decomposition](/records/algorithms/pag-node-decomposition)", "term": "project" }, { "description": "[PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "constrain" }, { "description": "[PAG Semantic Operation](/records/algorithms/pag-tool-invocation)", "term": "act" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate)", "term": "verify" }, { "description": "[PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation)", "term": "terminate" } ], "kind": "glossary" }, { "code": "An instruction written as prose, ungated, untyped and unwatched.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frontmatter + typed declaration → meta block with jurisdiction → nodes each headed, contracted and closed by a handoff gate → directives{semantic operations, control flow, structure declarations} → INVARIANT records → REPORT", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "[PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-authoring-kernel", "title": "PAG Authoring Kernel" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Scan a PAG document for structural and epistemic defects, each named for the shape it catches — a retired unit head, a node without a gate, a check without evidence, a gate without a population or with an empty one, an unknown left unrouted, a write without a refusal, an artifact without freshness, a node declared twice, an input naming no source, an invariant missing its set, parties or objector, a bare invariant block, a lowercase keyword, a bare FOR, a missing colon, a vague condition — and emit a token-based, regex-free verdict.", "term": "Intent" }, { "description": "A PAG document is trusted only after a deterministic well-formedness scan whose defect set is the epistemology's failure taxonomy, never because it reads fluently.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PagDocument → DefectScan → DefectSet → WellFormednessVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagWellFormedness ::= \"→\" \"→\" \nPagDefect ::= \"retired_unit_head\" | \"node_without_gate\" | \"node_tag_malformed\" | \"node_declared_twice\" | \"input_without_source\" | \"check_without_evidence\" | \"gate_without_population\" | \"empty_population\" | \"result_missing\" | \"unknown_unrouted\" | \"write_without_refusal\" | \"artifact_without_freshness\" | \"invariant_without_set\" | \"invariant_without_parties\" | \"invariant_without_objector\" | \"bare_invariant_block\" | \"gate_too_few_conditions\" | \"gate_too_many_conditions\" | \"vague_condition\" | \"for_without_each\" | \"lowercase_keyword\" | \"missing_colon\" | \"no_declaration\"\nPagWellFormednessVerdict ::= \"well_formed\" | \"ill_formed\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow)", "term": "Composes" }, { "description": "[PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A PAG document trusted because it reads fluently.", "kind": "code", "language": "text", "title": "Before" }, { "code": "document → defect scan{retired unit head, node without gate, check without evidence, gate without population, empty population, unknown unrouted, write without refusal, artifact without freshness, node declared twice, input without source, invariant without set/parties/objector, bare invariant block, lowercase keyword, for without each, missing colon, vague condition} → well-formed | ill-formed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-well-formedness-validation", "title": "PAG Well-Formedness Validation" }, { "blocks": [ { "items": [ "Domain: [pag](/records/algorithms-domain/pag)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "Any PAG artifact should be treated as a structured instruction contract whose tokens are drawn from a fixed ontology grounded in the reasoning collection, whose nodes are closed by evidence-bearing gates that carry their population and route unknown to blocked, and whose invariants name their objector, reducing interpretive ambiguity without guaranteeing deterministic output.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DocumentType → Keywords → Nodes → Gates → OperationsAndStructure → Invariant → WellFormedness", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PagInstructionConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[metaprogramming_modeling](/records/force/metaprogramming-modeling), [model_governance](/records/force/model-governance), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, whose defect set is the grammar's failure taxonomy", "term": "Checked by" }, { "description": "Every agent and template document written in the grammar", "term": "Population" }, { "description": "A verdict stands until a document or the grammar changes", "term": "Freshness" }, { "description": "The validation stage fails on any defect code", "term": "Refusal" }, { "description": "None, because a document is verified before any run", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants each defect code in a node-form document and validates a well-formed document clean", "term": "Evidence" }, { "description": "The grammar, which every document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pag-instruction-concern", "title": "" } ], "title": "Pattern Abstract Grammar" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_analysis_workspace[\"Analysis Workspace\"]\n n_registry_baseline[\"Registry Baseline\"]\n n_compliance_gap[\"Compliance Gap\"]\n n_semantic_domain_partitioning[\"Semantic Domain Partitioning\"]\n n_behavioral_signature_extraction[\"Behavioral Signature Extraction\"]\n n_cross_class_pattern_detection[\"Cross-Class Pattern Detection\"]\n n_behavioral_inconsistency[\"Behavioral Inconsistency\"]\n n_sequential_chain_duplication[\"Sequential Chain Duplication\"]\n n_temporal_coupling_detection[\"Temporal Coupling Detection\"]\n n_relational_graph_duplication[\"Relational Graph Duplication\"]\n n_causal_wiring_duplication[\"Causal Wiring Duplication\"]\n n_anomaly_outlier_detection[\"Anomaly Outlier Detection\"]\n n_conceptual_duplication_detection[\"Conceptual Duplication Detection\"]\n n_fractal_scale_duplication[\"Fractal Scale Duplication\"]\n n_anti_pattern_classification[\"Anti-Pattern Classification\"]\n n_anti_pattern_priority_matrix[\"Anti-Pattern Priority Matrix\"]\n n_abstraction_boundary_principle[\"Abstraction Boundary Principle\"]\n n_base_class_candidate_selection[\"Base-Class Candidate Selection\"]\n n_concrete_vs_abstract_responsibility_split[\"Concrete-vs-Abstract Responsibility Split\"]\n n_template_method_lifecycle[\"Template Method Lifecycle\"]\n n_base_schematic_composition[\"Base Schematic Composition\"]\n n_migration_ordering[\"Migration Ordering\"]\n n_backup_verified_migration[\"Backup-Verified Migration\"]\n n_anti_pattern_elimination_verification[\"Anti-Pattern Elimination Verification\"]\n n_registry_regeneration[\"Registry Regeneration\"]\n n_anti_reintroduction_gate[\"Anti-Reintroduction Gate\"]\n n_distillation_metrics[\"Distillation Metrics\"]\n n_pattern_distillation_history[\"Pattern Distillation History\"]\n n_pattern_distillation_completion_truthfulness[\"Pattern Distillation Completion Truthfulness\"]\n n_pattern_distiller_kernel[\"Pattern Distiller Kernel\"]\n n_pattern_distillation_concern[\"\"]\n n_pattern_distiller_kernel --> n_analysis_workspace\n n_pattern_distiller_kernel --> n_registry_baseline\n n_pattern_distiller_kernel --> n_compliance_gap\n n_pattern_distiller_kernel --> n_semantic_domain_partitioning\n n_pattern_distiller_kernel --> n_cross_class_pattern_detection\n n_pattern_distiller_kernel --> n_anti_pattern_classification\n n_pattern_distiller_kernel --> n_base_class_candidate_selection\n n_pattern_distiller_kernel --> n_base_schematic_composition\n n_pattern_distiller_kernel --> n_registry_regeneration\n n_pattern_distiller_kernel --> n_distillation_metrics\n n_pattern_distiller_kernel --> n_behavioral_signature_extraction\n n_pattern_distiller_kernel --> n_anti_pattern_priority_matrix\n n_pattern_distiller_kernel --> n_migration_ordering\n n_pattern_distiller_kernel --> n_backup_verified_migration\n n_pattern_distiller_kernel --> n_anti_pattern_elimination_verification\n n_pattern_distiller_kernel --> n_pattern_distillation_history\n n_pattern_distiller_kernel --> n_pattern_distillation_completion_truthfulness" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-pattern-distillation", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Create a unique analysis session, allocate phase/metric/migration artifact locations, load baseline documentation and registries, write a manifest, and block continuation if required context is unavailable.", "term": "Intent" }, { "description": "Architectural refactoring must begin from an auditable workspace with explicit input provenance.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Session → Workspace → ContextLoad → Manifest → Gate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AnalysisWorkspace ::= \"→\" \"→\" \"→\" \"→\" \nInitializationGate ::= \"workspace_exists\" \",\" \"manifest_written\" \",\" \"baseline_docs_loaded\" \",\" \"registry_loaded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Refactoring begins ad hoc, with no auditable record of what it started from.", "kind": "code", "language": "text", "title": "Before" }, { "code": "session → workspace{phase/metric/migration locations} → load baseline + registries → manifest → block if required context missing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-analysis-workspace", "title": "Analysis Workspace" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read existing architectural registries, extract known base abstractions, count implementations, measure hierarchy depth, and record the current abstraction state before proposing changes.", "term": "Intent" }, { "description": "New abstractions must be compared against existing architecture before being created.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Registry → ExistingAbstractions → ImplementationCounts → HierarchyMetrics → Baseline", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RegistryBaseline ::= \"→\" \"→\" \"→\" \"→\" \nImplementationMetricSet ::= \"total_base_classes\" \",\" \"total_implementations\" \",\" \"implementation_count_by_base\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A new base abstraction created without measuring what already exists.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry → existing bases + implementation counts + hierarchy depth → current abstraction state, before proposing a change", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-registry-baseline", "title": "Registry Baseline" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Discover implementation classes by role, detect which ones conform to expected base abstractions, calculate noncompliance counts, and compute architectural compliance rate.", "term": "Intent" }, { "description": "Pattern distillation must distinguish missing adoption from missing abstraction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleClasses → ExpectedBaseRule → ConformingSet + NonconformingSet → ComplianceRate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ComplianceGap ::= \"→\" \"→\" \"→\" \nBaseExpectation ::= \"extends\" \nGapReport ::= \"noncompliant_count\" \",\" \"compliant_count\" \",\" \"compliance_rate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'The Foos don't extend a base' — but is the base missing, or just its adoption?", "kind": "code", "language": "text", "title": "Before" }, { "code": "role classes → expected base rule → conforming vs nonconforming → compliance rate distinguishing missing adoption from missing abstraction", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-compliance-gap", "title": "Compliance Gap" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Group implementation resources by semantic role, such as manager, repository, handler, service, controller, adapter, or worker, then analyze each family separately.", "term": "Intent" }, { "description": "Reusable abstractions emerge from families of similar responsibility, not arbitrary files.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ResourceSet → RoleClassifier → SemanticDomains → DomainMetrics", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SemanticDomainPartitioning ::= \"→\" \"→\" \nSemanticDomain ::= \",\" \",\" \",\" \nRoleClassification ::= \"manager\" | \"repository\" | \"handler\" | \"service\" | \"controller\" | \"adapter\" | \"worker\" | \"unknown\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [performance_scaling](/records/force/performance-scaling), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Abstractions drawn from arbitrary files instead of families of like responsibility.", "kind": "code", "language": "text", "title": "Before" }, { "code": "resources → classify by role{manager|repository|handler|service|adapter} → per-family analysis", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-semantic-domain-partitioning", "title": "Semantic Domain Partitioning" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/axis-analysis)", "Yields: operation" ], "kind": "list" }, { "entries": [ { "description": "For each class in a semantic domain, inspect constructor behavior, lifecycle hooks, error handling, state management, dependency acquisition, and public orchestration methods.", "term": "Intent" }, { "description": "Base-class candidates require behavioral evidence, not just naming similarity.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ClassResource → BehaviorScan → Signature → DomainSignatureSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BehavioralSignature ::= \",\" \",\" \",\" \",\" \",\" \nLifecycleBehavior ::= \"initialize\" \",\" \"destroy\" \",\" \"onInitialize\" \",\" \"onDestroy\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[structural](/records/reasoning/lens-structure), [behavioral](/records/reasoning/lens-behavior)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "A base-class candidate proposed on naming similarity alone.", "kind": "code", "language": "text", "title": "Before" }, { "code": "class → scan{constructor, lifecycle hooks, error handling, state, dependencies, public methods} → behavioral signature (evidence, not names)", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-behavioral-signature-extraction", "title": "Behavioral Signature Extraction" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Search across semantic domains for repeated imports, repeated initialization, repeated lifecycle code, repeated error handling, repeated state setup, and repeated dependency wiring.", "term": "Intent" }, { "description": "Duplication becomes an abstraction candidate when it appears across multiple implementations with the same role.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DomainSignatures → CrossClassSearch → DuplicatePatternSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CrossClassPatternDetection ::= \"→\" \"→\" \nCrossClassPattern ::= \",\" \",\" \",\" \nPatternRole ::= \"initialization\" | \"lifecycle\" | \"error_handling\" | \"state_management\" | \"dependency_management\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[structural](/records/reasoning/lens-structure), [frequency](/records/reasoning/lens-frequency)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "One duplicated block noticed; the family-wide repetition stays invisible.", "kind": "code", "language": "text", "title": "Before" }, { "code": "signatures → search repeated{imports, init, lifecycle, error, state, deps} across the role family → cross-class pattern + occurrence count", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cross-class-pattern-detection", "title": "Cross-Class Pattern Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Detect multiple competing implementations of the same behavior, count each variation, compute dominant-pattern consistency, and flag low-consistency behavior for normalization.", "term": "Intent" }, { "description": "Inconsistent behavior is an architectural smell even when code is not textually duplicated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorFamily → VariationCounts → ConsistencyRate → NormalizeCandidate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BehavioralInconsistency ::= \"→\" \"→\" \"→\" \nConsistencyMetric ::= \"max_variation_count / total_variation_count\"\nInconsistencyVerdict ::= \"consistent\" | \"weakly_consistent\" | \"inconsistent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" }, { "description": "[behavioral](/records/reasoning/lens-behavior)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Three competing implementations of one behavior, none textually duplicated, so nothing flags.", "kind": "code", "language": "text", "title": "Before" }, { "code": "behavior family → variation counts → consistency = dominant/total → {consistent | weakly | inconsistent} → normalize the inconsistent", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-behavioral-inconsistency", "title": "Behavioral Inconsistency" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "For each class in the role family, extract the ordered sequence of orchestration steps, align sequences across the family, and surface repeated ordered chains that no textual-duplication scan would catch.", "term": "Intent" }, { "description": "Order-sensitive repetition is duplication even when no contiguous block is textually identical.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → OrderedCallSequence → SequenceAlignment → RepeatedChainSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SequentialChainDuplication ::= \"→\" \"→\" \nRepeatedOrderedChain ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "[ana-sequential](/records/reasoning/node-ana-sequential)", "term": "Grounds" }, { "description": "[sequential](/records/reasoning/lens-sequential)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Two classes call the same steps in the same order, but no single block is textually identical, so frequency scanning finds nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → extract ordered call-sequence per class → align sequences → repeated ordered chain + occurrence count", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-sequential-chain-duplication", "title": "Sequential Chain Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Detect must-precede and must-follow ordering constraints between operations in each class, intersect them across the role family, and surface the shared temporal-coupling contract that a base lifecycle would centralize.", "term": "Intent" }, { "description": "A lifecycle ordering constraint re-encoded across a family is a shared contract, not a per-class detail.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → OrderingConstraintSet → CrossFamilyIntersection → SharedCouplingContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemporalCouplingDetection ::= \"→\" \"→\" \nOrderingConstraint ::= \"must_precede\" | \"must_follow\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[ana-temporal](/records/reasoning/node-ana-temporal)", "term": "Grounds" }, { "description": "[temporal](/records/reasoning/lens-time)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Every class re-encodes 'call setup before use, teardown after' as scattered ad-hoc ordering, and the shared lifecycle contract stays invisible.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → must-precede/must-follow constraints per class → intersect across family → shared temporal-coupling contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-temporal-coupling-detection", "title": "Temporal Coupling Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Build the dependency-acquisition subgraph for each class, test for isomorphic subgraphs across the role family, and surface repeated object-graph wiring that a base or factory would assemble once.", "term": "Intent" }, { "description": "A dependency subgraph reassembled across a family is duplicated structure, distinct from duplicated statements.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → DependencySubgraph → SubgraphIsomorphism → RepeatedWiringSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RelationalGraphDuplication ::= \"→\" \"→\" \nRepeatedWiringSubgraph ::= \",\" \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[ana-relational](/records/reasoning/node-ana-relational)", "term": "Grounds" }, { "description": "[relational](/records/reasoning/lens-relation)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The same object graph — acquire A, wire B onto A, hand both to C — is reassembled by hand in every class.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → dependency-acquisition subgraph per class → subgraph isomorphism across family → repeated wiring subgraph", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-relational-graph-duplication", "title": "Relational Graph Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Extract cause-to-effect edges (event to handler, failure to recovery, state change to reaction) per class, match trigger/reaction pairs across the role family, and surface repeated causal wiring that a base policy would centralize.", "term": "Intent" }, { "description": "Repeated trigger-to-reaction wiring is duplicated causal policy even when the surrounding code differs.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → CausalEdgeSet → TriggerReactionMatch → RepeatedCausalWiringSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CausalWiringDuplication ::= \"→\" \"→\" \nCausalEdge ::= \"causes\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "[ana-causal](/records/reasoning/node-ana-causal)", "term": "Grounds" }, { "description": "[causal](/records/reasoning/lens-cause)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The same trigger-to-reaction wiring — this event runs that handler, that failure invokes this recovery — is duplicated across the family.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → cause→effect edges per class → match trigger/reaction pairs across family → repeated causal-wiring set", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-causal-wiring-duplication", "title": "Causal Wiring Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Score each class's deviation from the dominant behavioral signature, identify the outliers, and name why each deviates, so inconsistency is localized to the deviant implementation rather than reported as an aggregate rate.", "term": "Intent" }, { "description": "Inconsistency is an anomaly to be localized to a deviant implementation, not merely a family-level ratio.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BehaviorFamily → DominantSignature → DeviationScore → OutlierSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AnomalyOutlierDetection ::= \"→\" \"→\" \"→\" \nOutlier ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[ana-anomaly](/records/reasoning/node-ana-anomaly)", "term": "Grounds" }, { "description": "[anomaly](/records/reasoning/lens-anomaly)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "A family shares one behavior — except the one class that does it differently, and a consistency ratio only reports 'weakly consistent' without naming the deviant.", "kind": "code", "language": "text", "title": "Before" }, { "code": "behavior family → per-class deviation score against the dominant signature → outlier set + why each deviates → normalize or justify", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anomaly-outlier-detection", "title": "Anomaly Outlier Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Derive a name-independent semantic signature for each behavior (intent, input-to-output shape, effects), cluster behaviors by meaning rather than identifier, and surface same-meaning/different-name clusters that only the semantic lens can detect.", "term": "Intent" }, { "description": "Same meaning under different names is duplication that textual, structural, and frequency lenses are blind to.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RoleFamily → SemanticSignature → MeaningCluster → ConceptualDuplicateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConceptualDuplicationDetection ::= \"→\" \"→\" \nSemanticSignature ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[ana-semantic](/records/reasoning/node-ana-semantic)", "term": "Grounds" }, { "description": "[semantic](/records/reasoning/lens-meaning)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "Two implementations mean the same thing under different names, so no textual, structural, or frequency scan flags them.", "kind": "code", "language": "text", "title": "Before" }, { "code": "role family → semantic signature per behavior (intent, inputs→outputs, effects) → cluster by meaning not name → same-meaning/different-name set + novelty score", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-conceptual-duplication-detection", "title": "Conceptual Duplication Detection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Test whether a duplication shape recurs at more than one scale (method, class, module), and determine the scale at which the abstraction belongs, so single-scale scanning does not abstract at the wrong level.", "term": "Intent" }, { "description": "A shape that recurs across scales must be abstracted at the scale where it is invariant, not only where it was first noticed.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CandidateShape → MultiScaleRecurrence → ScaleInvariance → AbstractionScale", "kind": "code", "language": "text", "title": "Flow" }, { "code": "FractalScaleDuplication ::= \"→\" \"→\" \nScaleInvarianceVerdict ::= \"method_scale\" | \"class_scale\" | \"module_scale\" | \"scale_invariant\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ana-fractal](/records/reasoning/node-ana-fractal)", "term": "Grounds" }, { "description": "[fractal](/records/reasoning/lens-fractal)", "term": "Detector for" } ], "kind": "glossary" }, { "code": "The distiller scans one scale — the class family — and misses that the same shape repeats at the method level and again at the module level.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidate shape → test recurrence at method / class / module scale → scale-invariant duplication + the scale the abstraction belongs at", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-fractal-scale-duplication", "title": "Fractal Scale Duplication" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Convert duplicated, inconsistent, and architecture-violating findings into anti-pattern records with type, occurrence count, impact, effort, severity, and affected resources.", "term": "Intent" }, { "description": "Refactoring targets should be normalized into comparable anti-pattern contracts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Finding → AntiPatternRecord → PriorityInput", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiPatternClassification ::= \"→\" \nAntiPattern ::= \",\" \",\" \",\" \",\" \",\" \",\" \nAntiPatternType ::= \"copy_paste_duplication\" | \"behavioral_inconsistency\" | \"architectural_violation\" | \"conceptual_duplication\" | \"structural_duplication\" | \"sequential_duplication\" | \"temporal_coupling\" | \"relational_duplication\" | \"causal_duplication\" | \"scale_duplication\"\nPriorityRank ::= \"critical\" | \"high\" | \"medium\" | \"low\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Findings kept as loose notes, not comparable across the backlog.", "kind": "code", "language": "text", "title": "Before" }, { "code": "findings → anti-pattern records{type, occurrence, impact, effort, severity, affected resources}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-classification", "title": "Anti-Pattern Classification" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Assign numeric impact and effort scores, calculate priority, sort anti-patterns, and group them into remediation bands.", "term": "Intent" }, { "description": "Distillation should address high-value anti-patterns first.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern → ImpactScore + EffortScore → Priority → SortedBacklog", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PriorityMatrix ::= \"→\" \"→\" \nScoredAntiPattern ::= \",\" \",\" \",\" \nPriorityValue ::= \"*\" \nPriorityBand ::= \"priority_1\" | \"priority_2\" | \"priority_3\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Refactoring picks a target by gut feel, not value.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-patterns → impact * effort → priority → sorted into remediation bands", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-priority-matrix", "title": "Anti-Pattern Priority Matrix" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Evaluate each high-priority anti-pattern against boundary principles: universal, invariant, foundational, enforcing, and cognitive-load-reducing.", "term": "Intent" }, { "description": "A base abstraction is justified only when the behavior belongs below the subclass boundary.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern → BoundaryPrinciples → PrinciplesMet → AbstractionEligible", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundaryPrincipleEvaluation ::= \"→\" \"→\" \nBoundaryPrincipleSet ::= \"universal\" \",\" \"invariant\" \",\" \"foundational\" \",\" \"enforcing\" \",\" \"reducing_load\"\nEligibilityVerdict ::= \"base_candidate\" | \"utility_candidate\" | \"composition_candidate\" | \"local_refactor_only\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Duplication abstracted into a base whether or not the behavior belongs below the subclass boundary.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-pattern → boundary principles{universal, invariant, foundational, enforcing, load-reducing} → {base | utility | composition | local-refactor}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-abstraction-boundary-principle", "title": "Abstraction Boundary Principle" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Promote an anti-pattern to a base-class candidate only when it satisfies enough boundary principles and applies across a meaningful portion of the semantic domain.", "term": "Intent" }, { "description": "Inheritance should encode stable lifecycle or invariant behavior, not incidental reuse.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AntiPattern + DomainCoverage + BoundaryScore → Candidate|Reject", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BaseClassCandidateSelection ::= \",\" \",\" \"→\" \nCandidateVerdict ::= \"create_base_class\" | \"prefer_composition\" | \"prefer_utility\" | \"reject_abstraction\"\nDomainCoverage ::= \"occurrence_count / total_domain_classes\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Incidental reuse promoted to inheritance.", "kind": "code", "language": "text", "title": "Before" }, { "code": "anti-pattern + domain coverage + boundary score → verdict{create_base | prefer_composition | prefer_utility | reject}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-base-class-candidate-selection", "title": "Base-Class Candidate Selection" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Partition the family's behavior into what is invariant across every member (the topology preserved under substitution) and what varies per member (the novelty); the invariant set becomes the concrete base, the variant set becomes the abstract seam. The concrete/abstract boundary is derived from the evidence, not read off a fixed lifecycle vocabulary — so the split holds for any paradigm, not only OOP class lifecycles.", "term": "Intent" }, { "description": "The concrete/abstract boundary is the invariant/variant boundary of the family, discovered from evidence — never a pre-assumed lifecycle template.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FamilyBehaviorSet → InvariantPartition + VariantPartition → ConcreteBase + AbstractSeam", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ResponsibilitySplit ::= \"→\" \",\" \"→\" \",\" \nInvariantSet ::= \"behavior identical across every family member\"\nVariantSet ::= \"behavior that differs per family member\"\nAbstractSeam ::= \",\" \nSeamKind ::= \"hook\" | \"abstract_method\" | \"injected_strategy\" | \"parameter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [control_coordination](/records/force/control-coordination)", "term": "Forces" }, { "description": "[substrate-node:invariant](/records/reasoning/substrate-node-invariant), [ont-novelty](/records/reasoning/node-ont-novelty)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The split is drawn from a fixed OOP lifecycle vocabulary (constructor/initialize/destroy/onInitialize/executeCore), which pre-decides the shape whether or not the family's behavior matches it.", "kind": "code", "language": "text", "title": "Before" }, { "code": "family behavior → partition INVARIANT (identical across every member) from VARIANT (differs per member) → invariant set = concrete base, variant set = the abstract seam; the hook names are read from the variant behavior, not assumed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concrete-vs-abstract-responsibility-split", "title": "Concrete-vs-Abstract Responsibility Split" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Define public lifecycle methods that enforce guard checks, call shared setup or cleanup, invoke subclass hooks, and centralize error handling.", "term": "Intent" }, { "description": "Template method converts repeated lifecycle code into one predictable behavioral contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PublicMethod → Guard → SharedBehavior → Hook → ErrorPolicy → Result", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TemplateLifecycle ::= \"→\" \"→\" \"→\" \"→\" \nLifecycleMethod ::= \"initialize\" | \"destroy\" | \"execute\" | \"process\"\nSubclassHook ::= \"onInitialize\" | \"onDestroy\" | \"onExecute\" | \"onProcess\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each subclass re-implements the same guard-setup-cleanup lifecycle.", "kind": "code", "language": "text", "title": "Before" }, { "code": "public lifecycle method → guard → shared setup/cleanup → subclass hook → centralized error handling → one predictable contract", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-template-method-lifecycle", "title": "Template Method Lifecycle" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Generate the base abstraction from the selected candidate, enforce size constraints, split if oversized, and record which anti-patterns the abstraction eliminates.", "term": "Intent" }, { "description": "Generated abstractions must remain small enough to be maintainable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Candidate → GenerateBase → SizeCheck → SplitIfNeeded → BaseArtifact", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BaseSchematicComposition ::= \"→\" \"→\" \"→\" \nConstraintCheck ::= \"line_count <= max_allowed_lines\" \",\" \"name_matches_convention\" \",\" \"location_matches_architecture\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A base generated so large it becomes the new god object.", "kind": "code", "language": "text", "title": "Before" }, { "code": "candidate → generate base → size <= max (split if oversized) + name + location conventions → persistable base", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-base-schematic-composition", "title": "Base Schematic Composition" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Sort target classes by complexity from lowest to highest, migrate simpler implementations first, and use early migrations to validate the abstraction before complex adoption.", "term": "Intent" }, { "description": "Migration risk decreases when the base pattern is proven on low-complexity cases first.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TargetClasses → ComplexityMetric → SortedMigrationOrder", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MigrationOrdering ::= \"→\" \"→\" \nComplexityScore ::= \"line_count\" | \"method_count\" | \"dependency_count\" | \"state_property_count\"\nMigrationQueue ::= \"ascending_complexity\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [causality_ordering](/records/force/causality-ordering), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The most complex implementation migrated first, and the base is wrong before it's proven.", "kind": "code", "language": "text", "title": "Before" }, { "code": "target classes → complexity score → migrate ascending complexity → prove the base on simple cases first", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-migration-ordering", "title": "Migration Ordering" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "For each target class, create a recoverable checkpoint, refactor it to extend or use the abstraction, verify the removed anti-pattern no longer exists, and restore from backup on failure.", "term": "Intent" }, { "description": "Structural migration must be reversible per target artifact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Backup → Refactor → Verify → Commit|Restore", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MigrationExecution ::= \"→\" \"→\" \"→\" \"→\" \nMigrationOutcome ::= \"committed\" | \"restored_from_checkpoint\" | \"failed_with_log\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [streaming_dataflow](/records/force/streaming-dataflow), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A refactor breaks a target and there is no way back.", "kind": "code", "language": "text", "title": "Before" }, { "code": "per target → checkpoint → refactor to the base → verify the anti-pattern is gone → commit | restore from checkpoint", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-backup-verified-migration", "title": "Backup-Verified Migration" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "After migration, search the entire target scope for old duplicate patterns, allow only approved base-location occurrences, and fail completion if unapproved duplicates remain.", "term": "Intent" }, { "description": "Refactoring is incomplete until the old pattern is gone.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "KnownAntiPattern → ScopeSearch → RemainingOccurrences → Pass|Fail", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiPatternElimination ::= \"→\" \"→\" \"→\" \nEliminationVerdict ::= \"eliminated\" | \"remaining_unapproved_occurrences\" | \"base_only_occurrence\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Distillation declared done while the old pattern still lives at three sites.", "kind": "code", "language": "text", "title": "Before" }, { "code": "known anti-pattern → search the whole scope → allow only approved base-location occurrences → fail completion on unapproved duplicates", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-pattern-elimination-verification", "title": "Anti-Pattern Elimination Verification" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "After creating or migrating abstractions, regenerate or update the architecture registry, reread it, and confirm the new base and migrated implementations are represented.", "term": "Intent" }, { "description": "Architecture metadata must reflect the new implementation truth.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RefactorResult → RegistryRegeneration → RegistryReadback → RepresentationCheck", "kind": "code", "language": "text", "title": "Flow" }, { "code": "RegistryRegeneration ::= \"→\" \"→\" \"→\" \nRegistryVerification ::= \"new_base_present\" \",\" \"implementation_count_updated\" \",\" \"old_pattern_absent_or_marked\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The registry still reflects the pre-refactor architecture.", "kind": "code", "language": "text", "title": "Before" }, { "code": "migration result → regenerate registry → reread → confirm new base + migrated implementations represented", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-registry-regeneration", "title": "Registry Regeneration" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "After eliminating an anti-pattern, author or strengthen the custom lint rule that statically forbids its reintroduction and any bypass of the new base, build the rule plugin, and regenerate the rule catalog, so the distilled boundary is enforced by a gate rather than by discipline.", "term": "Intent" }, { "description": "A distilled pattern is incomplete until a gate forbids its reintroduction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "DistilledBoundary → LintRuleAuthored → PluginBuilt → CatalogRegenerated → EnforcedBoundary", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AntiReintroductionGate ::= \"→\" \"→\" \"→\" \"→\" \nEnforcementVerdict ::= \"gate_active\" | \"gate_absent\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The distilled base eliminates the duplication today, but nothing stops the developer or the model from reintroducing the same anti-pattern — the gate held only for this run, by discipline.", "kind": "code", "language": "text", "title": "Before" }, { "code": "distilled boundary → author/strengthen a custom lint rule forbidding the anti-pattern + the base-bypass → build the plugin → regenerate the rule catalog → the boundary is enforced structurally", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-anti-reintroduction-gate", "title": "Anti-Reintroduction Gate" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [probability](/records/reasoning/math-type-probability)", "Yields: number[0,1]" ], "kind": "list" }, { "entries": [ { "description": "Calculate duplication reduction, code reduction, adoption rate, lines saved, maintenance burden reduction, and cognitive-load reduction after migration.", "term": "Intent" }, { "description": "Refactoring should produce measurable architectural ROI.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "BeforeMetrics + AfterMetrics → ReductionMetrics → ROISummary", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationMetrics ::= \",\" \"→\" \nFinalMetricSet ::= \"duplication_reduction\" \",\" \"code_reduction\" \",\" \"base_class_adoption\" \",\" \"lines_saved\" \",\" \"maintenance_burden_reduction\" \",\" \"cognitive_load_reduction\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "ROI asserted ('much cleaner now') with no numbers.", "kind": "code", "language": "text", "title": "Before" }, { "code": "before + after → {duplication reduction, code reduction, adoption rate, lines saved, maintenance + cognitive-load reduction}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-distillation-metrics", "title": "Distillation Metrics" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Append the completed analysis summary to a durable history log, store metric snapshots, and preserve lessons learned for future abstraction decisions.", "term": "Intent" }, { "description": "Refactoring intelligence improves when outcomes become reusable historical evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Summary → HistoryAppend → MetricSnapshot → LessonsLearned", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationHistory ::= \"→\" \"→\" \"→\" \nReusableLearning ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Each distillation forgets the last — the same lessons re-learned.", "kind": "code", "language": "text", "title": "Before" }, { "code": "summary → durable history log + metric snapshots + lessons → reusable evidence for future abstraction decisions", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-history", "title": "Pattern Distillation History" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Mark pattern distillation complete only if workspace, baseline, semantic analysis, anti-pattern classification, abstraction selection, migration, verification, registry update, anti-reintroduction gate, and metrics logging all pass.", "term": "Intent" }, { "description": "Completion is an evidence state, not an assertion — and it includes a gate that forbids the anti-pattern's return.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PhaseGates → VerificationResults → Metrics → Complete|Incomplete", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DistillationCompletion ::= \",\" \",\" \",\" \",\" \",\" \",\" \",\" \"→\" \nCompletionVerdict ::= \"pattern_distillation_complete\" | \"pattern_distillation_incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "'Done' asserted while verification, registry-update, and the anti-reintroduction gate never ran.", "kind": "code", "language": "text", "title": "Before" }, { "code": "gates{workspace, baseline, semantic, anti-pattern, abstraction, migration, verification, registry, enforcement, metrics} all pass → complete; else incomplete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-completion-truthfulness", "title": "Pattern Distillation Completion Truthfulness" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Initialize an analysis workspace, read registry baselines, partition semantic domains, extract behavioral signatures, detect anti-patterns, prioritize them, evaluate abstraction boundaries, compose base schematics, migrate targets, verify elimination, update registries, calculate ROI, and persist history.", "term": "Intent" }, { "description": "Pattern distillation is a forensic compiler from repeated behavioral evidence into predictable implementation architecture.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Workspace → Registry → Semantics → AntiPatterns → Abstraction → Migration → Verification → Metrics → History", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternDistillerKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Registry Regeneration](/records/algorithms/registry-regeneration), [Distillation Metrics](/records/algorithms/distillation-metrics)", "term": "Composes" }, { "description": "[Custom-Rule Derivation](/records/algorithms/custom-rule-derivation)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Premature Abstraction](/records/architecture/premature-abstraction)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace)", "term": "orient" }, { "description": "[Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)", "term": "see" }, { "description": "[Anti-Pattern Classification](/records/algorithms/anti-pattern-classification)", "term": "derive" }, { "description": "[Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix)", "term": "intent" }, { "description": "[Migration Ordering](/records/algorithms/migration-ordering)", "term": "project" }, { "description": "[Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "act" }, { "description": "[Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification)", "term": "verify" }, { "description": "[Pattern Distillation History](/records/algorithms/pattern-distillation-history)", "term": "commit" }, { "description": "[Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness)", "term": "terminate" } ], "kind": "glossary" }, { "code": "Repeated behavior abstracted by intuition, migrated irreversibly, never verified.", "kind": "code", "language": "text", "title": "Before" }, { "code": "workspace → baseline → semantics → anti-patterns → abstraction boundary → base schematic → reversible migration → elimination proof → registry regenerate → ROI → history", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "[Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Registry Regeneration](/records/algorithms/registry-regeneration), [Distillation Metrics](/records/algorithms/distillation-metrics)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distiller-kernel", "title": "Pattern Distiller Kernel" }, { "blocks": [ { "items": [ "Domain: [pattern-distillation](/records/algorithms-domain/pattern-distillation)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → → ", "term": "Intent" }, { "description": "Any repeated implementation behavior should become a shared abstraction only when evidence proves it is universal, invariant, foundational, enforceable, and cognitively load-reducing.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → Semantics → AntiPattern → Boundary → Abstraction → Migration → Verification → Metrics", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PatternDistillationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nAbstractionBoundary ::= \"universal\" \",\" \"invariant\" \",\" \"foundational\" \",\" \"enforcing\" \",\" \"reducing_load\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the anti-pattern elimination verification and the anti-reintroduction gate, the duplication detectors the analysis lenses name", "term": "Checked by" }, { "description": "Every class family the analysis partitions", "term": "Population" }, { "description": "A verdict stands until the family's code or the architecture registry changes", "term": "Freshness" }, { "description": "Completion is refused until the old pattern is gone and a gate forbids its return", "term": "Refusal" }, { "description": "None, because distillation is verified on source", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The distilled pattern, which the family's code migrates to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-pattern-distillation-concern", "title": "" } ], "title": "Pattern distillation" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_profile_compose[\"Profile Compose\"]\n n_delta_capture[\"Delta Capture\"]\n n_idempotent_merge[\"Idempotent Merge\"]\n n_version_provenance[\"Version Provenance\"]\n n_deterministic_merge_core[\"Deterministic Merge Core\"]\n n_persistence_fork[\"Persistence Fork\"]\n n_seed_composition[\"Seed Composition\"]\n n_living_profile_kernel[\"Living Profile Kernel\"]\n n_living_accumulation_concern[\"\"]\n n_living_profile_kernel --> n_seed_composition\n n_living_profile_kernel --> n_delta_capture\n n_living_profile_kernel --> n_idempotent_merge\n n_living_profile_kernel --> n_version_provenance\n n_living_profile_kernel --> n_persistence_fork\n n_living_profile_kernel --> n_profile_compose\n n_living_accumulation_concern --> n_version_provenance\n n_living_accumulation_concern --> n_persistence_fork" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-living-profile", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing the RAG Knowledge Boundary, read the durable profile document (or an empty one), strip volatile metadata, and project a compact view injected into reasoning as retrieved memory rather than ground truth.", "term": "Intent" }, { "description": "Accumulated knowledge is disclosed as supported evidence, not authority; the consumer still grounds every use against live source.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Store → ReadDoc|Empty → StripVolatileMetadata → CompactView → ContextInjection", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ProfileCompose ::= \"→\" ( | ) \"→\" \"→\" \"→\" \nCompactKnowledgeView ::= \"without\" \nContextEvidence ::= \"disclosed_as_memory\" \",\" \"not_ground_truth\" \",\" \"reverifiable_against_source\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulated profile knowledge treated as ground truth, never re-verified.", "kind": "code", "language": "text", "title": "Before" }, { "code": "profile store → read doc (or empty) → strip volatile metadata → compact view → injected as disclosed memory, reverifiable against source", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-profile-compose", "title": "Profile Compose" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing the RAG Knowledge Boundary, accept a structured knowledge delta the reasoning turn self-reports inline, admit only facts verified within that same turn, and reject speculation without a separate extraction pass.", "term": "Intent" }, { "description": "A durable fact enters the profile only from evidence produced in the same turn; unsupported claims are rejected, never guessed into memory.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StructuredTurn → KnowledgeDelta|Null → VerifiedThisTurnFilter → AdmissibleDelta", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DeltaCapture ::= \"→\" ( | ) \"→\" \"→\" \nEvidenceFilter ::= \"verified_this_turn\" \"→\" \"supported\" | \"unverified\" \"→\" \"unsupported_reject\"\nAdmissibleDelta ::= ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A speculative claim written into durable memory without same-turn evidence.", "kind": "code", "language": "text", "title": "Before" }, { "code": "structured turn → knowledge delta → keep only facts verified this turn → admissible delta; unverified rejected", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-delta-capture", "title": "Delta Capture" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Idempotent Side Effect, assign each fact a stable identity, apply the delta per field kind, deduplicate and cap, and guarantee that re-applying the same delta yields the same document.", "term": "Intent" }, { "description": "Merge is idempotent and bounded — the same delta applied twice is a no-op, and no axis grows without limit.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Doc + Delta → StableFactIdentity → PerFieldKindMerge → DedupeAndCap → MergedDoc", "kind": "code", "language": "text", "title": "Flow" }, { "code": "IdempotentMerge ::= \",\" \"→\" \"→\" \"→\" \"→\" \nFieldKind ::= \"scalar_overwrite\" | \"set_union\" | \"list_append_dedupe_cap\"\nDedupeAndCap ::= \"dedupe_by_stable_identity\" \",\" \"cap_list_axis_to_limit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Idempotent Side Effect](/records/algorithms/idempotent-side-effect)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[state_transaction](/records/force/state-transaction)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Re-applying the same delta grows an axis and changes the document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "doc + delta → stable fact identity → per-field-kind merge{overwrite | union | append-dedupe-cap} → double-apply is a no-op", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Idempotent Side Effect](/records/algorithms/idempotent-side-effect)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-idempotent-merge", "title": "Idempotent Merge" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Specializing Governance Evolution, detect whether the merge changed state, and only on real change bump the version, timestamp it, and append a modification record — leaving a no-op untouched.", "term": "Intent" }, { "description": "A no-op delta bumps nothing; every real change is auditable and reversible, and a version is never mutated in place without a provenance record.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "MergedDoc → ChangeDetect → (NoOp | VersionBump + Timestamp + ModificationRecord) → VersionedDoc", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VersionProvenance ::= \"→\" \"→\" ( | )\nChangeDetection ::= \"merged_equals_prior\" \"→\" \"no_op\" | \"merged_differs\" \"→\" \"versioned\"\nVersionedOutcome ::= \",\" \",\" \nModificationRecord ::= \"at\" \",\" \"changed_axes\" \",\" \"prior_version\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel), [](/records/algorithms/living-accumulation-concern), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[security_governance](/records/force/security-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A version bumped and mutated in place even on a no-op merge.", "kind": "code", "language": "text", "title": "Before" }, { "code": "merged doc → change detect → {no-op: untouched | real change: bump + timestamp + modification record}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-version-provenance", "title": "Version Provenance" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Deterministic Core, keep compose and merge pure functions over immutable inputs with the clock injected, so identical inputs reproduce identical outputs.", "term": "Intent" }, { "description": "No hidden time, state, or randomness — the clock is a parameter, and merge is referentially transparent.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "(Doc, Delta, Clock) → PureMerge → (Doc', Modification|Null)", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ProfileMergeCore ::= \",\" \",\" \"→\" \"→\" ( \",\" )\nPurityConstraint ::= \"no_hidden_state\" \",\" \"no_hidden_time\" \",\" \"no_hidden_randomness\" \",\" \"referential_transparency\"\nInjectedClock ::= \"now_supplied_by_adapter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Merge reads the wall clock internally, so identical inputs differ.", "kind": "code", "language": "text", "title": "Before" }, { "code": "(doc, delta, injected clock) → pure merge → (doc', modification|null); no hidden time/state/randomness", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Deterministic Core](/records/algorithms/deterministic-core)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-deterministic-merge-core", "title": "Deterministic Merge Core" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Specializing the Port Adapter, resolve the durable store by connection mode — an authoritative per-owner store when the trusted arm is connected, a read-only mirror otherwise — and write back only where accumulation is trusted.", "term": "Intent" }, { "description": "Authoritative accumulation happens only against the trusted store; the fallback is a read mirror, never a divergent source of truth.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConnectionMode → AuthoritativeStore|LimitedMirror → ScopedKey → Persist|MirrorReadOnly", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PersistenceFork ::= \"→\" ( | ) \"→\" \"→\" \nConnectionMode ::= \"trusted_arm_connected\" | \"disconnected_limited\"\nPersistenceOutcome ::= \"persist_write_back\" | \"mirror_read_only\"\nScopedOwnerKey ::= \"stable_owner_identity\" \",\" \"sanitized\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Port Adapter](/records/algorithms/port-adapter)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel), [](/records/algorithms/living-accumulation-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulation written to a fallback mirror, creating a divergent source of truth.", "kind": "code", "language": "text", "title": "Before" }, { "code": "connection mode → {trusted arm connected: authoritative per-owner store, write back | disconnected: read-only mirror}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Port Adapter](/records/algorithms/port-adapter)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-persistence-fork", "title": "Persistence Fork" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Specializing Canonical Data, overlay the accumulated knowledge onto the frozen baseline scope as additive context without mutating the baseline.", "term": "Intent" }, { "description": "The frozen baseline is an immutable source of truth; accumulated knowledge is additive context, never a rewrite of scope.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "FrozenBaseline + ComposedKnowledge → AdditiveOverlay → TurnSeed", "kind": "code", "language": "text", "title": "Flow" }, { "code": "SeedComposition ::= \",\" \"→\" \"→\" \nAdditiveOverlay ::= \"baseline_immutable\" \",\" \"knowledge_appended_not_merged_into_baseline\"\nTurnSeed ::= \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Composed by" }, { "description": "[Living Profile Kernel](/records/algorithms/living-profile-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Accumulated knowledge merged into the baseline, rewriting frozen scope.", "kind": "code", "language": "text", "title": "Before" }, { "code": "frozen baseline + composed knowledge → additive overlay (baseline immutable) → turn seed", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-seed-composition", "title": "Seed Composition" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose the accumulated knowledge onto the frozen baseline into a seed, run the reasoning turn, capture the inline verified delta, merge it idempotently under an injected clock, version only real change, and persist against the fork — looping per turn.", "term": "Intent" }, { "description": "A living profile is a versioned, idempotently accumulated, provenance-logged memory that grows only from verified per-turn evidence and never overrides frozen scope or live source.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Baseline → Compose → Seed → Turn → Delta → Merge(Clock) → Version → Persist → (next turn)", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingProfileKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nKernelInvariant ::= \"grows_only_from_verified_evidence\" \",\" \"never_overrides_frozen_scope\" \",\" \"never_overrides_live_source\" \",\" \"bounded_and_idempotent\" \",\" \"auditable_and_reversible\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Seed Composition](/records/algorithms/seed-composition), [Delta Capture](/records/algorithms/delta-capture), [Idempotent Merge](/records/algorithms/idempotent-merge), [Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork), [Profile Compose](/records/algorithms/profile-compose)", "term": "Composes" }, { "description": "[model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[Versioning](/records/architecture/versioning)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Seed Composition](/records/algorithms/seed-composition)", "term": "orient" }, { "description": "[Delta Capture](/records/algorithms/delta-capture)", "term": "verify" }, { "description": "[Idempotent Merge](/records/algorithms/idempotent-merge)", "term": "act" }, { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "commit" } ], "kind": "glossary" }, { "code": "Per-turn evidence written to memory ungated, unbounded, unversioned.", "kind": "code", "language": "text", "title": "Before" }, { "code": "compose → seed → turn → capture verified delta → idempotent merge (injected clock) → version only real change → persist against the fork → loop", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Seed Composition](/records/algorithms/seed-composition), [Delta Capture](/records/algorithms/delta-capture), [Idempotent Merge](/records/algorithms/idempotent-merge), [Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork), [Profile Compose](/records/algorithms/profile-compose)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-profile-kernel", "title": "Living Profile Kernel" }, { "blocks": [ { "items": [ "Domain: [living-profile](/records/algorithms-domain/living-profile)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "Any per-turn evidence stream becomes durable memory only when accumulation is idempotent, bounded, provenance-logged, deterministic at its core, and additive to an immutable baseline it may never rewrite.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → Admissibility → IdempotentMerge → Provenance → Persistence → AdditiveOverlay", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingAccumulationConcern ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nIdempotentBoundedMerge ::= \"stable_identity\" \",\" \"dedupe\" \",\" \"cap\" \",\" \"double_apply_is_no_op\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [streaming_dataflow](/records/force/streaming-dataflow)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the merge core's determinism and idempotency checks, the provenance log, which records every version and the evidence behind it", "term": "Checked by" }, { "description": "Every delta applied to the profile", "term": "Population" }, { "description": "A verdict stands until a new turn produces evidence or the frozen baseline changes", "term": "Freshness" }, { "description": "A delta without same-turn evidence is rejected, and the fallback mirror accepts no writes", "term": "Refusal" }, { "description": "The provenance log, which locates when and from what evidence each fact entered", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The same-turn evidence, which every delta cites, and the frozen baseline, which the mirror never overrides", "term": "Authoritative side" }, { "description": "[Version Provenance](/records/algorithms/version-provenance), [Persistence Fork](/records/algorithms/persistence-fork)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-accumulation-concern", "title": "" } ], "title": "Living profile" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_living_plan_state[\"Living Plan State\"]\n n_boundary_reconciliation[\"Boundary Reconciliation\"]\n n_phase_close_gate[\"Phase Close Gate\"]\n n_plan_phase_verification[\"Plan Phase Verification\"]\n n_governed_autonomous_plan_loop[\"Governed Autonomous Plan Loop\"]\n n_governed_plan_concern[\"\"]\n n_phase_close_gate --> n_boundary_reconciliation\n n_plan_phase_verification --> n_boundary_reconciliation\n n_governed_autonomous_plan_loop --> n_living_plan_state\n n_governed_autonomous_plan_loop --> n_boundary_reconciliation\n n_governed_autonomous_plan_loop --> n_phase_close_gate\n n_governed_autonomous_plan_loop --> n_plan_phase_verification\n n_governed_plan_concern --> n_living_plan_state\n n_governed_plan_concern --> n_phase_close_gate" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-governed-plan-loop", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Treat the plan as durable append/update-only state — tasks carrying status and grounding, a considerations backlog, and a dismissed-key set — maintained every turn and re-delivered on restart, so anything discovered mid-pass is retained instead of falling out of scope.", "term": "Intent" }, { "description": "Plan progress is authoritative persisted state, never inferred from transient conversation, and a completion is recorded only with evidence.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "EmitDelta → GuardTransition → AppendOnly → Persist → RenderFromState", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LivingPlanState ::= \"→\" \"→\" \"→\" \nTaskStatus ::= \"pending\" | \"active\" | \"done\"\nConsiderationStatus ::= \"open\" | \"confirmed\" | \"dismissed\"\nDoneTransition ::= \"requires\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [](/records/algorithms/governed-plan-concern)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[state_transaction](/records/force/state-transaction), [causality_ordering](/records/force/causality-ordering), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Plan progress inferred from the conversation, so a discovery mid-pass falls out of scope on restart.", "kind": "code", "language": "text", "title": "Before" }, { "code": "plan delta → transition guard{done requires grounding} → append/update-only durable state{tasks, considerations, dismissed keys} → render from state, restart-survivable", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-living-plan-state", "title": "Living Plan State" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Capture considerations during a phase but act on them only at the phase boundary — triage each open consideration against code and canon into a confirmed task or a dismissed resolved-false key, deduping new opens against the confirmed and dismissed sets before triage.", "term": "Intent" }, { "description": "A dismissed consideration never resurfaces and the backlog converges monotonically, so the loop cannot oscillate.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Capture → DeferToBoundary → DedupBeforeTriage → Triage → DryPassOrBound", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundaryReconciliation ::= \"→\" \"→\" \"→\" \nTriage ::= \"confirm\" \"→\" | \"dismiss\" \"→\" \nDedup ::= \"newOpens\" \"against\" \"(confirmed | resolvedFalse)\"\nTermination ::= \"dryPass\" | \"maxReconcileRounds\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Recursion Control](/records/algorithms/recursion-control)", "term": "Composes" }, { "description": "[Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[causality_ordering](/records/force/causality-ordering), [resilience_recovery](/records/force/resilience-recovery), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Considerations acted on mid-phase, and a dismissed one resurfaces — the loop oscillates.", "kind": "code", "language": "text", "title": "Before" }, { "code": "capture during phase → act only at the boundary → dedup new opens vs (confirmed | dismissed) → triage{confirm → task | dismiss → resolved-false} → dry pass or bound", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Recursion Control](/records/algorithms/recursion-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-boundary-reconciliation", "title": "Boundary Reconciliation" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Make completion a gated state of the plan rather than a judgment call — a phase closes only when all tasks are done, a dry reconciliation pass holds, verify is clean for the chosen scope, and the coverage graph confirms the ripple set; otherwise the loop returns to execution.", "term": "Intent" }, { "description": "Completion can never be self-declared; closure is a composed evidence-bound gate whose failure routes back to execution, never to done.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AllTasksDone → DryPass → VerifyClean → CoverageConfirmed → CloseOrExecute", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PhaseCloseGate ::= \"&\" \"&\" \"&\" \"→\" \nDecision ::= \"close\" | \"return_to_execute\"\nVerifyResult ::= \"scope:full\" | \"scope:work\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Validation Gate](/records/algorithms/validation-gate), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [](/records/algorithms/governed-plan-concern)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification), [state_transaction](/records/force/state-transaction)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The phase is self-declared done.", "kind": "code", "language": "text", "title": "Before" }, { "code": "all tasks done & dry reconciliation holds & verify clean (scope) & coverage graph confirms ripple → close | return to execute; never self-declared", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Validation Gate](/records/algorithms/validation-gate), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-phase-close-gate", "title": "Phase Close Gate" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Before a composed plan reaches the developer, the engine loops it back through evidence, completeness, and adversarial-skepticism passes, reconciles the findings into the plan, and increments a loop-owned pass counter the model cannot forge; a render boundary blocks an unverified plan.", "term": "Intent" }, { "description": "A plan is never presented un-reviewed, and the verification flag is written only by deterministic engine code, never by model tokens.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AutoLoopback → ThreePassVerify → ReconcileFindings → LoopOwnedIncrement → PresentGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PlanPhaseVerification ::= \"→\" \"→\" \"→\" \"→\" \nVerifyPasses ::= \"evidence\" \",\" \"completeness\" \",\" \"adversarial\"\nPresentGate ::= \"verificationPasses >= 1\"\nCounter ::= \"loop_owned\" \"not_model_emitted\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Recursion Control](/records/algorithms/recursion-control)", "term": "Composes" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Composed by" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A plan presented to the developer un-reviewed, its verified flag set by model tokens.", "kind": "code", "language": "text", "title": "Before" }, { "code": "auto loopback → 3 passes{evidence, completeness, adversarial} → reconcile findings → loop-owned counter (not model-emitted) → render blocked until verified", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Recursion Control](/records/algorithms/recursion-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-plan-phase-verification", "title": "Plan Phase Verification" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Drive a large task to completion under gates — seed per phase, investigate, execute, self-inform from canon and self-audit, capture considerations, reconcile at the boundary, and close only when the plan is a mechanically resolved state, then re-seed the next phase.", "term": "Intent" }, { "description": "Autonomy is bounded by gates rather than disposition — the plan can only grow with code-verified work, completion is a gated state and not a judgment call, and every step is restart-survivable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SeedPhase → Investigate → Execute → GatedSelfAuditAndInform → CaptureConsiderations → BoundaryReconcile → CloseGate → ReSeedNextPhase", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedPlanLoop ::= \"→\" \"→\" \"→\" \"→\" \nActivityCycle ::= \"investigate\" \"→\" \"execute\" \"→\" \"verify\"\nSelfDrive ::= \"&\" \"&\" \nCompletion ::= \"gated_state\" \"not_judgment_call\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Phase-Separated Execution](/records/algorithms/phase-separated-execution)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [security_governance](/records/force/security-governance), [correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "[Auditability](/records/architecture/auditability)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" }, { "description": "[constrain](/records/stage/constrain)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state)", "term": "commit" }, { "description": "[Boundary Reconciliation](/records/algorithms/boundary-reconciliation)", "term": "constrain" }, { "description": "[Plan Phase Verification](/records/algorithms/plan-phase-verification)", "term": "verify" }, { "description": "[Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A long task driven from conversation memory, self-declared done, losing mid-pass discoveries on restart.", "kind": "code", "language": "text", "title": "Before" }, { "code": "seed phase → investigate → execute → gated self-audit + canon self-inform → capture + reconcile at boundary → close only on a mechanically resolved gated state → re-seed next phase", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Phase-Separated Execution](/records/algorithms/phase-separated-execution)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-autonomous-plan-loop", "title": "Governed Autonomous Plan Loop" }, { "blocks": [ { "items": [ "Domain: [governed-plan-loop](/records/algorithms-domain/governed-plan-loop)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → ", "term": "Intent" }, { "description": "A large task reaches completion only under gates, never by disposition: the plan grows solely from code-verified work, completion is a gated state rather than a judgment call, and every step is restart-survivable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SeedPhase → GatedActivity → BoundaryReconcile → CloseGate → ReSeed", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedPlanConcern ::= \"→\" \"→\" \"→\" \"→\" \nGatedActivityCycle ::= \"investigate\" \"→\" \"execute\" \"→\" \"gated_self_audit\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "Composes" }, { "description": "[state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the phase close gate, whose verification flag only deterministic engine code writes", "term": "Checked by" }, { "description": "Every phase and task of the living plan", "term": "Population" }, { "description": "A verdict stands until the plan or the verified work changes", "term": "Freshness" }, { "description": "A phase does not close while its gate fails, and a failure routes back to execution", "term": "Refusal" }, { "description": "The persisted plan state, which records progress across restarts", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The engine's verification flag, which a phase closes on", "term": "Authoritative side" }, { "description": "[Living Plan State](/records/algorithms/living-plan-state), [Phase Close Gate](/records/algorithms/phase-close-gate)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-plan-concern", "title": "" } ], "title": "Governed plan loop" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_quality_governance_loop[\"Quality Governance Loop\"]\n n_canonical_config_resolution[\"Canonical Config Resolution\"]\n n_stage_ordering[\"Stage Ordering\"]\n n_comment_normalization_remediation[\"Comment Normalization Remediation\"]\n n_custom_rule_derivation[\"Custom-Rule Derivation\"]\n n_machine_verdict_derivation[\"Machine Verdict Derivation\"]\n n_bounded_cascade_termination[\"Bounded Cascade Termination\"]\n n_quality_engine_concern[\"Quality-Engine Kernel\"]\n n_quality_governance_loop --> n_canonical_config_resolution\n n_quality_governance_loop --> n_stage_ordering\n n_quality_governance_loop --> n_comment_normalization_remediation\n n_quality_governance_loop --> n_machine_verdict_derivation\n n_quality_governance_loop --> n_bounded_cascade_termination\n n_quality_engine_concern --> n_canonical_config_resolution\n n_quality_engine_concern --> n_stage_ordering\n n_quality_engine_concern --> n_quality_governance_loop" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-quality-engine", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "On each update (an apply), normalize the proposal, resolve a CheckPlan, verify it, and on failure fix-then-reverify the downstream set until the verdict is clean or the pass bound is reached, then escalate.", "term": "Intent" }, { "description": "Every code update is a bounded verify-remediate loop keyed to the apply event, not the turn; the machine verdict — never the model's read — is its only completion signal.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Update → Normalize → Resolve → Verify → Clean? → Fix → Reverify → Clean|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QualityGovernanceLoop ::= \"→\" \"→\" \"→\" \"→\" ( | \"→\" )\nDownstreamFixCycle ::= \"→\" \"→\" \"→\" \nBoundedReverify ::= \"passCount <= MAX_CASCADE_PASSES\" \"AND\" \"in_scope_findings_strictly_decrease\" | \"escalate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Recursion Control](/records/algorithms/recursion-control), [Resilience Control](/records/algorithms/resilience-control)", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance), [model_governance](/records/force/model-governance), [event_messaging](/records/force/event-messaging)", "term": "Forces" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution)", "term": "derive" }, { "description": "[Stage Ordering](/records/algorithms/stage-ordering)", "term": "project" }, { "description": "[Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation)", "term": "act" }, { "description": "[Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation)", "term": "verify" }, { "description": "[Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination)", "term": "terminate" } ], "kind": "glossary" }, { "code": "A code edit judged clean by the model's read, not the machine verdict.", "kind": "code", "language": "text", "title": "Before" }, { "code": "apply → normalize → resolve CheckPlan → verify → {clean | fix in-scope + reverify, bounded, findings strictly decrease} → clean | escalate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Recursion Control](/records/algorithms/recursion-control), [Resilience Control](/records/algorithms/resilience-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-quality-governance-loop", "title": "Quality Governance Loop" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Expand one canonical config across selected profiles and native rules into per-tool config, resolve exactly one owner per contested surface, detect the four conflict kinds fail-closed, route loosening or self-certification to the developer's gate, and emit a resolved plan.", "term": "Intent" }, { "description": "A single canonical model expands to many tools without contradiction only when every contested surface has one owner and every conflict is caught before runtime.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CanonicalConfig → Expand → OwnershipResolution → ConflictDetection → HumanAuthorityRouting → ResolvedPlan|ConflictReport", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CanonicalConfigResolution ::= \"→\" \"→\" \"→\" \"→\" ( | )\nConflictKind ::= \"ownership_overlap\" | \"unsatisfiable_on_fixed\" | \"value_out_of_range\" | \"known_bad_pair\"\nResolution ::= \"single_owner_enabled\" | \"route_to_human_authority_gate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "One config expanded to many tools with contradictory, unowned rules.", "kind": "code", "language": "text", "title": "Before" }, { "code": "canonical config → per-tool expansion → one owner per contested surface → detect conflicts{ownership overlap, unsatisfiable, out-of-range, known-bad-pair} fail-closed → resolved plan | conflict report", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-canonical-config-resolution", "title": "Canonical Config Resolution" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Build the runnability DAG from dependsOn, topologically order the cascade by the invalidates relation so fixes point forward, partition into normalization prefix, structural band, and semantic suffix, and permit back-edges only inside the suffix.", "term": "Intent" }, { "description": "The order determines the total work scope; a forward-pointing order makes each fix dirty only later stages, so the prefix converges once and the suffix is bounded.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Stages → RunnabilityDAG → InvalidatesTopoSort → BandPartition → OrderedStages", "kind": "code", "language": "text", "title": "Flow" }, { "code": "StageOrdering ::= \"→\" \"→\" \"→\" \"→\" \nBandPartition ::= \"normalization_prefix\" \",\" \"structural_band\" \",\" \"semantic_suffix\"\nBackEdgePolicy ::= \"allowed_only_in_semantic_suffix_resolved_at_runtime\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality-Engine Kernel](/records/algorithms/quality-engine-concern)", "term": "Composed by" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Checks run in arbitrary order, so a fix re-dirties an already-passed stage forever.", "kind": "code", "language": "text", "title": "Before" }, { "code": "stages → runnability DAG (dependsOn) → topo-order by invalidates (fixes point forward) → bands{normalization prefix, structural, semantic suffix}; back-edges only in the suffix", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-stage-ordering", "title": "Stage Ordering" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Express the comment-strip rule once as canonical behavior, bind it per language from a comment-grammar descriptor, run the toolchain-free token-scan backing on the in-memory proposal and the real-AST backing in the sandbox, preserve directive comments, and trust a backing only after calibration and adversarial testing.", "term": "Intent" }, { "description": "An agnostic auto-fix is behavior-as-data compiled per language behind a safety boundary — adding a language is adding a descriptor, not code.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CanonicalRule + GrammarDescriptor → Compile → TokenScan|ASTBacking → DirectivePreservingStrip → CalibratedFix", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CommentNormalization ::= \"→\" \"→\" \"→\" \"→\" \nCompiledBacking ::= \"ast_lite_token_scan_in_memory\" | \"real_ast_via_tier_p_sandbox\"\nSafetyBoundary ::= \"tool_calibration\" \",\" \"adversarial_input_testing\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A comment-strip auto-fix hardcoded per language, so adding a language means new code.", "kind": "code", "language": "text", "title": "Before" }, { "code": "canonical rule + comment-grammar descriptor → compile per language → token-scan (in-memory) | real-AST (sandbox) → preserve directive comments → trust only after calibration + adversarial test", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-comment-normalization-remediation", "title": "Comment Normalization Remediation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Derive a candidate rule from repeated evidence through anti-pattern classification, boundary-principle evaluation, and candidate selection, migrate with rollback, verify elimination, and admit a tightening rule while routing a self-certifying or loosening rule through the developer's gate.", "term": "Intent" }, { "description": "A rule that governs the model's own output cannot be authored or loosened by the model; tightening is admitted, self-certification is gated.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Evidence → AntiPattern → BoundaryPrinciple → Candidate → Migrate → Verify → Admit|HumanGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CustomRuleDerivation ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nSelfCertGate ::= \"tightening_admitted\" | \"self_certifying_or_loosening_routes_to_human_authority\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The model authors and loosens a rule that governs its own output.", "kind": "code", "language": "text", "title": "Before" }, { "code": "repeated evidence → anti-pattern classify → boundary principle → candidate → migrate with rollback → verify elimination → {tightening admitted | self-certify/loosen routes to the developer's gate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Backup-Verified Migration](/records/algorithms/backup-verified-migration)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-custom-rule-derivation", "title": "Custom-Rule Derivation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Derive the verify-stage verdict from the toolchain's machine output — exit codes and parsed findings — never from the model's reading, so a clean verdict is an observed machine fact.", "term": "Intent" }, { "description": "The verify verdict is machine-derived from exit codes and parsed findings; a model's judgment is never the completion signal.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "CheckResults → ExitCodesAndFindings → MachineVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "MachineVerdictDerivation ::= \"→\" \"→\" \nMachineVerdict ::= \"clean\" | \"violations\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A pass declared from the model's reading of the diff, not the tool's exit.", "kind": "code", "language": "text", "title": "Before" }, { "code": "check results → exit codes + parsed findings → machine verdict{clean | violations}; the model's read is never the signal", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-machine-verdict-derivation", "title": "Machine Verdict Derivation" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Terminate the verify-remediate cascade on the completion AND-gate — a clean verdict, or bounded progress where findings strictly decrease within the pass bound — escalating when neither holds.", "term": "Intent" }, { "description": "The cascade terminates on a clean machine verdict or a violated progress bound; it never loops unbounded and never stops on an unclean state without escalating.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PassResult → CompletionGate → Stop|Continue|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "BoundedCascadeTermination ::= \"→\" \"→\" ( | | )\nCompletionGate ::= \"clean\" | \"findings_strictly_decrease\" \"AND\" \"passCount <= MAX_CASCADE_PASSES\" | \"escalate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [resilience_recovery](/records/force/resilience-recovery)", "term": "Forces" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A remediation cascade that loops until it happens to pass, or forever.", "kind": "code", "language": "text", "title": "Before" }, { "code": "each pass → {clean: stop | findings strictly decrease AND passCount <= MAX: continue | else: escalate}", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-bounded-cascade-termination", "title": "Bounded Cascade Termination" }, { "blocks": [ { "items": [ "Domain: [quality-engine](/records/algorithms-domain/quality-engine)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Resolve a canonical policy into a per-ecosystem CheckPlan, order its stages by the invalidates relation, normalize the proposal, run generation checks on the server and project tools via the relay, derive a machine verdict, and drive a bounded downstream cascade to clean — holding no runtime execution in the engine itself.", "term": "Intent" }, { "description": "Language-agnostic code governance is a pure planner-plus-judge behind a port; execution lives in the relay and the loop, the verdict is machine-derived, and the config gate has already removed every runtime contradiction.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Policy → Resolve → Order → Normalize → Execute(G+P) → Verdict → Cascade → Clean|Escalate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "QualityEngineKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nCheckPlanExecution ::= \"generation_checks_server_side\" \",\" \"project_commands_via_relay\"\nVerdictDerivation ::= \"exit_code\" | \"parse_findings\"\nEngineBoundary ::= \"pure_core_no_runtime_execution_behind_port_adapter\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the machine verdict, derived from the tools' exit codes and parsed findings", "term": "Checked by" }, { "description": "Every file the configured tools reach", "term": "Population" }, { "description": "A verdict stands until the code or the configuration changes", "term": "Freshness" }, { "description": "The cascade stops on a violated progress bound and escalates, and reports clean only on a clean verdict", "term": "Refusal" }, { "description": "None, because the verdict is derived from tool output", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The tools' exit codes and parsed findings, which the verdict is derived from", "term": "Authoritative side" }, { "description": "[Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Quality Governance Loop](/records/algorithms/quality-governance-loop)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-quality-engine-concern", "title": "Quality-Engine Kernel" } ], "title": "Quality engine" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_composed_turn_contract[\"Composed Turn Contract\"]\n n_loop_owned_mode_selection[\"Loop-Owned Mode Selection\"]\n n_versioned_turn_provenance[\"Versioned Turn Provenance\"]\n n_mode_contract_validation[\"Mode Contract Validation\"]\n n_mode_driven_response_schema[\"\"]\n n_loop_owned_mode_selection --> n_composed_turn_contract\n n_loop_owned_mode_selection --> n_mode_contract_validation\n n_loop_owned_mode_selection --> n_versioned_turn_provenance\n n_mode_driven_response_schema --> n_composed_turn_contract\n n_mode_driven_response_schema --> n_loop_owned_mode_selection\n n_mode_driven_response_schema --> n_versioned_turn_provenance" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-mode-driven-response-schema", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Compose a model turn's validation schema and its instruction from one self-registering field registry, projected per mode, so the schema the response is graded against and the instruction the model is given can never drift.", "term": "Intent" }, { "description": "The per-mode validation schema and the per-mode instruction are projections of a single field registry; there is no second hand-authored contract surface, and adding or changing a field changes both at once.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RegisterField → SelectByMode → ProjectSchema → ProjectInstruction → StampVersion", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ComposedTurnContract ::= \"→\" \"→\" \nModeKey ::= \"(\" \"phase\" \",\" \"activity\" \")\"\nSchemaVersion ::= \"content_hash\" \"(\"
\")\"\nDeterminism ::= \"same_mode\" \"→\" \"byte_identical\" \"(\" \",\" \")\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Canonical Semantics](/records/algorithms/canonical-semantics), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The validation schema and the model's instruction hand-maintained twice, so they drift.", "kind": "code", "language": "text", "title": "Before" }, { "code": "field registry → project per (phase, activity) mode → schema + instruction from one source → same mode = byte-identical, changing a field changes both", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Canonical Semantics](/records/algorithms/canonical-semantics), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-composed-turn-contract", "title": "Composed Turn Contract" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "The loop assigns the (phase, activity) mode that selects which contract a response is validated against; the model's output carries no contract-selecting field, so a model can never grade itself against a contract it chose.", "term": "Intent" }, { "description": "The mode that selects the response contract is loop-assigned; the model has no field that selects the contract it is graded against.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LoopAssignMode → ComposeContract → ValidateAgainstContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LoopOwnedModeSelection ::= \"→\" \"→\" \nModeAuthority ::= \"loop_owned\" \"not_model_selected\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Contract Compatibility](/records/algorithms/contract-compatibility)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[security_governance](/records/force/security-governance), [state_transaction](/records/force/state-transaction), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract)", "term": "act" }, { "description": "[Mode Contract Validation](/records/algorithms/mode-contract-validation)", "term": "verify" }, { "description": "[Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance)", "term": "commit" } ], "kind": "glossary" }, { "code": "The model's output carries the field that selects which contract it's graded against.", "kind": "code", "language": "text", "title": "Before" }, { "code": "loop assigns (phase, activity) mode → compose contract → validate; the model can never grade itself against a contract it chose", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Contract Compatibility](/records/algorithms/contract-compatibility)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-loop-owned-mode-selection", "title": "Loop-Owned Mode Selection" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Persist each accepted model turn as an append-only, mode-tagged, schema-versioned, causally ordered record with change-only provenance, so the turn history is a queryable, auditable log and a turn is never graded against a schema version its stored state never saw.", "term": "Intent" }, { "description": "Turn records are append-only and single-writer causally ordered; a version is stamped by content and never mutated in place; a no-op change appends nothing.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "StampVersion → AssignCausalOrder → AppendOnly → BumpOnChange → Query", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VersionedTurnProvenance ::= \"→\" \"→\" \nCausalOrder ::= \"single_writer_counter\" \"not\" \"disk_read_max\"\nProvenance ::= \"bump_on_real_change\" \"no_op_appends_nothing\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "Composes" }, { "description": "[](/records/algorithms/mode-driven-response-schema)", "term": "Composed by" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[observability_traceability](/records/force/observability-traceability), [state_transaction](/records/force/state-transaction), [causality_ordering](/records/force/causality-ordering)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A turn graded against a schema version its stored state never saw.", "kind": "code", "language": "text", "title": "Before" }, { "code": "accepted turn → stamp version by content → single-writer causal order → append-only, mode-tagged record; a no-op appends nothing", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Version Provenance](/records/algorithms/version-provenance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-versioned-turn-provenance", "title": "Versioned Turn Provenance" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Validate the model's response against the loop-selected mode contract and, on a validation miss, drive an error-specific self-healing retry bounded by the contract, so a response is accepted only when it satisfies the schema it is graded against.", "term": "Intent" }, { "description": "A response is accepted only against the mode contract the loop selected; a validation miss self-heals with error-specific remediation, never against a relaxed contract.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Response → ValidateAgainstContract → Valid|SelfHealRetry → Accepted|Rejected", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModeContractValidation ::= \",\" \"→\" \"→\" ( | \"→\" )\nSelfHealRetry ::= \"error_specific_remediation\" \"(\" \")\" \"bounded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A response accepted because it looked right, not because it satisfied the mode's schema.", "kind": "code", "language": "text", "title": "Before" }, { "code": "response + mode contract → validate → {valid | error-specific self-heal retry, bounded} → accepted | rejected", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-mode-contract-validation", "title": "Mode Contract Validation" }, { "blocks": [ { "items": [ "Domain: [mode-driven-response-schema](/records/algorithms-domain/mode-driven-response-schema)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Make the model's structured output a mode-driven composed contract — the output mirror of composed input context: per loop-owned mode the schema and instruction are projected from one field registry, the response is validated and self-heals against it, the typed fields are governed, and every turn is persisted as a versioned queryable record — so the output has one source, cannot drift from its instruction, and can be audited.", "term": "Intent" }, { "description": "The response contract is composed per loop-owned mode from a single field registry; instruction and validation are the same source; a validation miss self-heals with error-specific remediation; output governance is advisory and never blocks the hard verify gate; and every accepted turn is a versioned, append-only record.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ComposeContract → ValidateByMode → SelfRemediate → GovernFields → PersistVersioned", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ModeDrivenResponseSchema ::= \"→\" \"→\" \"→\" \"→\" \nSingleSource ::= \"instruction\" \"=\" \"validation\" \"=\" \"projection\" \"(\" \")\"\nSelfRemediation ::= \"error_specific_retry\" \"(\" \",\" \")\"\nGroundingAdvisory ::= \"typed_field\" \"→\" \"validator\" \"(\" \"advisory_not_blocking\" \")\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Contract Compatibility](/records/algorithms/contract-compatibility), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Extension Point](/records/algorithms/extension-point)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency), [runtime_extensibility](/records/force/runtime-extensibility), [correctness_verification](/records/force/correctness-verification), [security_governance](/records/force/security-governance)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the mode contract validation, which accepts a response only against the contract the loop selected", "term": "Checked by" }, { "description": "Every model turn the loop grades", "term": "Population" }, { "description": "A verdict stands until the field registry or the selected mode changes", "term": "Freshness" }, { "description": "A response that fails its mode contract is rejected and retried with error-specific remediation, never against a relaxed contract", "term": "Refusal" }, { "description": "The append-only turn records, which locate a failed turn", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The selected mode contract, which every graded response conforms to", "term": "Authoritative side" }, { "description": "[Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Interface Contract](/records/algorithms/interface-contract), [Canonical Data](/records/algorithms/canonical-data), [Contract Compatibility](/records/algorithms/contract-compatibility), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Extension Point](/records/algorithms/extension-point)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-mode-driven-response-schema", "title": "" } ], "title": "Mode-driven response schema" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_cascade_layer_partition[\"Cascade Layer Partition\"]\n n_token_source_of_truth[\"Token Source-of-Truth\"]\n n_type_keyed_appearance[\"Type-Keyed Appearance\"]\n n_custom_type_registration[\"Custom Type Registration\"]\n n_governed_construction_boundary[\"Governed Construction Boundary\"]\n n_placement_isolation[\"Placement Isolation\"]\n n_assembly_composition[\"Assembly Composition\"]\n n_layer_fitness_enforcement[\"Layer Fitness Enforcement\"]\n n_type_migration_centralization[\"Type-Migration Centralization\"]\n n_css_type_cascade_concern[\"CSS Type-Cascade Kernel\"]\n n_css_type_cascade_concern --> n_cascade_layer_partition\n n_css_type_cascade_concern --> n_token_source_of_truth\n n_css_type_cascade_concern --> n_type_keyed_appearance\n n_css_type_cascade_concern --> n_custom_type_registration\n n_css_type_cascade_concern --> n_placement_isolation\n n_css_type_cascade_concern --> n_assembly_composition\n n_css_type_cascade_concern --> n_layer_fitness_enforcement" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-css-cascade", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Declare one ordered set of named cascade layers once at the stylesheet root, assign every rule to exactly one layer, and let layer order — not selector specificity nor source order — decide precedence, so values, appearance, placement, and assembly can never fight for the same declaration.", "term": "Intent" }, { "description": "Style precedence must be a property of the layer a rule lives in, not of how specific its selector is; an unlayered rule silently outranks every layer and is therefore forbidden.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Root → LayerOrderDeclaration → PerFileLayerBinding → LayerPrecedence → DeterministicCascade", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CascadeLayerPartition ::= \"→\" \"→\" \nLayerOrderDeclaration ::= \"@layer\" \"tokens\" \",\" \"globals\" \",\" \"shell\" \",\" \"components\" \",\" \"app\"\nLayeredBinding ::= \"assigned_to\" \nPrecedencePolicy ::= \"app_over_components_over_shell_over_globals_over_tokens\" \",\" \"layer_beats_specificity\" \",\" \"no_unlayered_rule\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: red; }\n#page .foo { color: blue; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer tokens, globals, components, app;\n@layer globals { [data-el=\"foo\"] { color: var(--fg); } }\n@layer app { .foo-view { gap: var(--space-4); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-cascade-layer-partition", "title": "Cascade Layer Partition" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Define every design primitive — color, space, radius, the type scale, size, duration, z-index — exactly once as a custom property in the tokens layer, and forbid any downstream literal where a token exists.", "term": "Intent" }, { "description": "Values are canonical data with a single source; a literal in globals, components, or app where a token exists is duplication, not styling.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Primitive → TokenDeclaration → DownstreamReference → NoLiteralWhereTokenExists", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TokenSourceOfTruth ::= \"→\" \"→\" \nTokenCategory ::= \"color\" | \"space\" | \"radius\" | \"type_scale\" | \"size\" | \"duration\" | \"z_index\"\nLiteralPolicy ::= \"reference_token\" | \"zero_value_exempt\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [performance_scaling](/records/force/performance-scaling)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: #33bb55; }\n.bar { color: #33bb55; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer tokens { :root { --foo: #33bb55; } }\n@layer globals { [data-el=\"foo\"], [data-el=\"bar\"] { color: var(--foo); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-token-source-of-truth", "title": "Token Source-of-Truth" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "In the globals layer, define how every element and component type looks, its size, and its spacing exactly once, keyed only by element tag, `data-el` custom type, and the orthogonal `data-*` axes (`data-variant` paint, `data-size` scale, `data-gap` child rhythm, `data-tone` palette, `data-measure` width); never key appearance by a purpose-class, and let every value be a token.", "term": "Intent" }, { "description": "Appearance is a contract owned by a type, not by a use-site; a purpose-class in globals fragments one type's look across many call-sites and is forbidden.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Type → GlobalAppearanceRule → DefinedOncePerType → TokenizedValues", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TypeKeyedAppearance ::= \"→\" \"→\" \nTypeSelector ::= | \"[data-el=\" \"]\" | \"[data-\" (\"variant\"|\"size\"|\"gap\"|\"tone\"|\"measure\"|\"layout\") \"=\" \"]\"\nAppearanceProperty ::= \"look\" | \"size\" | \"spacing\" | \"intrinsic_rendering_behavior\"\nForbiddenKey ::= \"purpose_class\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Canonical Data](/records/algorithms/canonical-data), [Domain Boundary](/records/algorithms/domain-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo-label { font-size: 12px; color: gray; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer globals { [data-el=\"foo\"] { font-size: var(--text-sm); color: var(--fg-muted); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Canonical Data](/records/algorithms/canonical-data), [Domain Boundary](/records/algorithms/domain-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-type-keyed-appearance", "title": "Type-Keyed Appearance" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Extend the stylable element vocabulary beyond the native HTML tag set by registering each semantic type against a base tag and a `data-el` stamp; the registered type becomes a first-class node the globals layer binds one appearance contract to, so a concept no native tag can express — a field-label, an icon, a toast, an entry — is styled by its type, never by a class.", "term": "Intent" }, { "description": "The set of stylable types is open and self-registered, not limited to the HTML tag set; a new appearance contract is a newly registered type plus one global rule, never a new purpose-class.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "SemanticConcept → DefineElement(type, baseTag, dataEl) → TypeRegistry → DataElStamp → GlobalAppearanceContract", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CustomTypeRegistration ::= \"→\" \"→\" \"→\" \"→\" \nElementDefinition ::= \"type\" \",\" \"baseTag\" \",\" \"dataElToken\"\nRenderedTypeStamp ::= \"carrying\" \"data-el=\" \nAppearanceBinding ::= \"[data-el=\" \"]\" \"owns_exactly_one_global_appearance_rule\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Extension Point](/records/algorithms/extension-point), [Self-Description Manifest](/records/algorithms/self-description-manifest)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "**…**\n.foo { color: gray; }", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "defineElement({ type: \"foo\", baseTag: \"output\", dataEl: \"foo\" });\n@layer globals { [data-el=\"foo\"] { color: var(--fg-muted); } }", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Extension Point](/records/algorithms/extension-point), [Self-Description Manifest](/records/algorithms/self-description-manifest)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-custom-type-registration", "title": "Custom Type Registration" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Route all DOM creation through one governed factory that resolves a node spec of shape `{ el, variant, size, gap, tone, measure, layout, class, on, children }` against the type, handler, and component registries, maps each axis key to its `data-*` attribute, treats `class` as a gated hook (icon-font glyph, `u-*` utility, or `c-*` component — never bespoke, never appearance), throws on any unknown type, handler, or component, and refuses an inline `style` attribute.", "term": "Intent" }, { "description": "The construction surface must be structurally incapable of producing a node that is unstyled-by-type or carries an inline style; the illegal state is unrepresentable, not merely linted after the fact.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "NodeSpec → RegistryResolution → ScalarMapping → UnknownReject|InlineStyleReject → GovernedNode", "kind": "code", "language": "text", "title": "Flow" }, { "code": "GovernedConstruction ::= \"→\" \"→\" \"→\" \"→\" \nNodeSpec ::= \"el\" \",\" \"variant?\" \",\" \"size?\" \",\" \"gap?\" \",\" \"tone?\" \",\" \"measure?\" \",\" \"layout?\" \",\" \"class?\" \",\" \"on?\" \",\" \"children?\"\nScalarApplication ::= \"each_axis_key→data-attr\" \",\" \"class=gated_iconfont_or_u_or_c\"\nGuardSet ::= \"throw_on_unknown_element\" \",\" \"throw_on_unknown_handler\" \",\" \"throw_on_unknown_component\" \",\" \"reject_style_attribute\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Construction Boundary](/records/algorithms/construction-boundary), [Error Boundary](/records/algorithms/error-boundary), [Security Policy](/records/algorithms/security-policy)", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [object_creation](/records/force/object-creation)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "const n = document.createElement(\"div\");\nn.className = \"foo\";\nn.style.color = \"red\";", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "const n = dom({ el: \"foo\", tone: \"bar\", children: [text] });", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Construction Boundary](/records/algorithms/construction-boundary), [Error Boundary](/records/algorithms/error-boundary), [Security Policy](/records/algorithms/security-policy)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-governed-construction-boundary", "title": "Governed Construction Boundary" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [topology](/records/reasoning/math-type-topology)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "In the components layer, set only where a component sits — position, offsets, stacking, overlay — keyed by its type, and never its look, size, or spacing, which remain owned by globals.", "term": "Intent" }, { "description": "Placement and appearance are separate contracts; a placement rule that also sets a look re-opens a type's appearance outside its single global definition and breaks the layer partition.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ComponentType → PlacementRule → PositionStackingOverlayOnly → NoAppearanceLeak", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PlacementIsolation ::= \"→\" \"→\" \nPlacementProperty ::= \"position\" | \"inset\" | \"top\" | \"right\" | \"bottom\" | \"left\" | \"z_index\" | \"float\" | \"clear\"\nForbiddenInComponents ::= \"color\" | \"font\" | \"size\" | \"spacing\" | \"border\" | \"radius\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary), [Coupling Control](/records/algorithms/coupling-control)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "@layer components { [data-el=\"foo\"] { position: fixed; inset-block-end: 1rem; color: white; } }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer components { [data-el=\"foo\"] { position: fixed; inset-block-end: var(--space-4); z-index: var(--z-overlay); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary), [Coupling Control](/records/algorithms/coupling-control)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-placement-isolation", "title": "Placement Isolation" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "In the app layer, compose views from structural containers and arrange their children with flex or grid and token-valued gaps, pad each container once so its children are full-width and fill the padded box, forbid horizontal margins, and never set or override any element's or component's look.", "term": "Intent" }, { "description": "Assembly arranges typed parts and owns child layout plus gutter discipline, but holds zero appearance authority, so a view can be recomposed without restyling a single type.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "View → ContainerSet → ChildArrangement → GutterConvention → NoAppearanceOverride", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AssemblyComposition ::= \"→\" \"→\" \"→\" \nChildArrangement ::= \"flex\" | \"grid\" | \"token_valued_gap\"\nGutterConvention ::= \"container_pads_once\" \",\" \"child_width_100\" \",\" \"no_horizontal_margin\" \",\" \"narrower_via_explicit_width\" \",\" \"zero_margin_exempt\"\nAppearanceAuthority ::= \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "@layer app { .foo-view .bar { margin: 0 12px; box-shadow: 0 1px 2px; } }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer app { .foo-view { display: grid; gap: var(--space-4); padding-inline: var(--space-4); } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Responsibility Boundary](/records/algorithms/responsibility-boundary)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-assembly-composition", "title": "Assembly Composition" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Bind each layer invariant to a machine check — layer order declared once, placement properties barred from globals, class selectors barred from globals, literals barred where a token exists, no horizontal margin, all DOM through the factory, no inline style — run them as hard errors with no warn tier and no inline disables, and gate the push on a clean verdict.", "term": "Intent" }, { "description": "A layer contract holds only if a fitness function fails the build when it is broken; the factory makes appearance-by-type unrepresentable and the linters make any residue unshippable.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LayerInvariant → FitnessFunction → StaticCheck → HardErrorNoWarn → PushGate", "kind": "code", "language": "text", "title": "Flow" }, { "code": "LayerFitnessEnforcement ::= \"→\" \"→\" \nCssFitnessRule ::= \"layer_order\" | \"no_appearance_in_components_or_app\" | \"no_class_in_globals\" | \"layered_class_format_c_or_u\" | \"no_bespoke_class\" | \"tokens_only\" | \"axis_value_validation\" | \"no_horizontal_margin\"\nDomFitnessRule ::= \"factory_only_creation\" | \"no_inline_style\"\nGatePolicy ::= \"hard_error_no_warn_tier\" \",\" \"no_inline_disable\" \",\" \"block_push_on_fail\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Verification Fitness](/records/algorithms/verification-fitness)", "term": "Composes" }, { "description": "[CSS Type-Cascade Kernel](/records/algorithms/css-type-cascade-concern)", "term": "Composed by" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [object_creation](/records/force/object-creation), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "reviewChecklist.push(\"no appearance in the app layer\");", "kind": "code", "language": "typescript", "title": "Before" }, { "code": "export const rules = { \"no-appearance-in-app\": \"error\", \"factory-only-creation\": \"error\" };", "kind": "code", "language": "typescript", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Verification Fitness](/records/algorithms/verification-fitness)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-layer-fitness-enforcement", "title": "Layer Fitness Enforcement" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "To move an existing purpose-class or page-scoped stylesheet into this model, treat every appearance-bearing class rule as a migration unit, derive the element type it decorates, register a custom `data-el` type when no tag or variant expresses it, move its look, size, and spacing into one global rule keyed by that type, demote any residual position into components and any residual layout into app, and verify that zero appearance rule keyed by a purpose-class remains outside the globals layer.", "term": "Intent" }, { "description": "Migration is centralization by type: each scattered purpose-class appearance collapses into one type-keyed global rule, and completion is proven by the absence of appearance outside globals, not by a narrative claim.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "PurposeClassRule → DeriveType → RegisterTypeIfNeeded → MoveAppearanceToGlobals → DemoteResidue → ZeroAppearanceClassOutsideGlobals", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TypeMigration ::= \"→\" \"→\" \"→\" \"→\" \nTypeDerivation ::= \"existing_tag\" | \"existing_variant\" | \"register_new_data_el_type\"\nResidueDemotion ::= \"placement→components\" \",\" \"layout→app\"\nZeroDuplicationVerdict ::= \"no_appearance_keyed_by_purpose_class_outside_globals\" | \"incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [correctness_verification](/records/force/correctness-verification), [model_governance](/records/force/model-governance), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": ".foo { color: white; background: blue; position: sticky; top: 0; }", "kind": "code", "language": "text", "title": "Before" }, { "code": "@layer globals { [data-el=\"foo\"] { color: var(--fg-on-accent); background: var(--bg-accent); } }\n@layer components { [data-el=\"foo\"] { position: sticky; top: 0; } }", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Centralization Kernel](/records/algorithms/centralization-kernel), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-type-migration-centralization", "title": "Type-Migration Centralization" }, { "blocks": [ { "items": [ "Domain: [css-cascade](/records/algorithms-domain/css-cascade)", "Tier: [leaf](/records/vocabulary/domain-tier-leaf)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": "Declare one layer order, hold every value in tokens, key every appearance on a type — native or custom-registered — exactly once in globals, hold placement in components and assembly in app, create all DOM through a factory that stamps types and refuses inline style, and gate the whole contract behind machine fitness functions.", "term": "Intent" }, { "description": "Styling is reproducible when precedence is layer-decided, appearance is a per-type contract, the type vocabulary is open and factory-stamped, and every invariant has a build-failing check.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "LayerOrder → Tokens → TypeKeyedGlobals → Placement → Assembly → GovernedFactory → Fitness", "kind": "code", "language": "text", "title": "Flow" }, { "code": "CssTypeCascadeKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \nStylingBoundary ::= \"values_in_tokens\" \",\" \"appearance_by_type_in_globals\" \",\" \"app_frame_in_shell\" \",\" \"structure_in_components\" \",\" \"assembly_in_app\"\nOpenTypeVocabulary ::= \"native_tag\" | \"registered_data_el_custom_type\"\nCascadeContract ::= \"layer_decides_precedence\" \",\" \"one_definition_per_property_per_type\" \",\" \"factory_and_linters_enforce\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Custom Type Registration](/records/algorithms/custom-type-registration), [Placement Isolation](/records/algorithms/placement-isolation), [Assembly Composition](/records/algorithms/assembly-composition), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Composes" }, { "description": "[contract_compatibility](/records/force/contract-compatibility), [object_creation](/records/force/object-creation), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Single Source of Truth](/records/architecture/single-source-of-truth)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the stylesheet linters and the element construction factory, the layer fitness functions that fail the build when the partition breaks", "term": "Checked by" }, { "description": "Every stylesheet and every element the factory constructs", "term": "Population" }, { "description": "A verdict stands until a stylesheet, the tokens or the factory change", "term": "Freshness" }, { "description": "The lint stage fails an unlayered rule, a literal where a token exists, or appearance declared outside the global type rules", "term": "Refusal" }, { "description": "None, because the cascade is decided statically", "term": "Observation" }, { "description": "None, because the catalog states this check as a class, so a watched run belongs to each system that adopts it", "term": "Evidence" }, { "description": "The layer order and the token set, which every stylesheet conforms to", "term": "Authoritative side" }, { "description": "[Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Custom Type Registration](/records/algorithms/custom-type-registration), [Placement Isolation](/records/algorithms/placement-isolation), [Assembly Composition](/records/algorithms/assembly-composition), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-css-type-cascade-concern", "title": "CSS Type-Cascade Kernel" } ], "title": "CSS cascade" }, { "blocks": [ { "caption": "What composes what inside this domain.", "kind": "mermaid", "text": "flowchart LR\n n_taxonomy_jurisdiction[\"Taxonomy Jurisdiction\"]\n n_reshape_risk_priority[\"Reshape Risk Priority\"]\n n_path_role_walk[\"Path Role Walk\"]\n n_concern_classification[\"Concern Classification\"]\n n_name_projection[\"Name Projection\"]\n n_container_reshape[\"Container Reshape\"]\n n_vocabulary_admission_gate[\"Vocabulary Admission Gate\"]\n n_discovery_verification[\"Discovery Verification\"]\n n_taxonomy_ledger[\"Taxonomy Ledger\"]\n n_taxonomy_completion[\"Taxonomy Completion\"]\n n_container_ladder[\"Container Ladder\"]\n n_export_triage_ladder[\"Export Triage Ladder\"]\n n_dialect_resolution[\"Dialect Resolution\"]\n n_alignment_cadence[\"Alignment Cadence\"]\n n_taxonomy_kernel[\"Taxonomy Kernel\"]\n n_taxonomy_concern[\"\"]\n n_taxonomy_kernel --> n_taxonomy_jurisdiction\n n_taxonomy_kernel --> n_reshape_risk_priority\n n_taxonomy_kernel --> n_path_role_walk\n n_taxonomy_kernel --> n_concern_classification\n n_taxonomy_kernel --> n_name_projection\n n_taxonomy_kernel --> n_container_reshape\n n_taxonomy_kernel --> n_vocabulary_admission_gate\n n_taxonomy_kernel --> n_discovery_verification\n n_taxonomy_kernel --> n_taxonomy_ledger\n n_taxonomy_kernel --> n_taxonomy_completion" } ], "icon": "bi-diagram-2", "id": "algorithms-domain-taxonomy", "intro": "Every algorithm contract in this domain is listed with its position on the derivation loop, its intent and invariant, the flow it walks and its productions as a grammar. Each record also shows what it composes and is composed by, which forces and principles it answers to, what grounds it and what it grounds, and an exemplar where the record carries one. The diagram shows what composes what inside the domain.", "subsections": [ { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [orient](/records/stage/orient)", "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Yields: set | boolean" ], "kind": "list" }, { "entries": [ { "description": "Read the registry's root, container, bucket and ignore declarations, enumerate every file under a declared root, and separate the governed set from the ignored set and from the folders declared as neither, so jurisdiction is read rather than inferred.", "term": "Intent" }, { "description": "No declaration, no enforcement: a file is governed only under a declared root, and a root folder in neither the container nor the bucket declaration is a finding rather than a new container.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Registry → GovernedRootSet → ContainerSet → GovernedFileSet → FlaggedFolderSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyJurisdiction ::= \"→\" \"→\" \nJurisdictionPartition ::= \",\" \",\" \nGovernedRootSet ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Whether a file is governed is decided per file as it comes up, so an undeclared tree is silently exempt and a stray root-level folder reads as legitimate.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry → governed roots → containers + buckets + ignore entries → the governed file set, and the flagged set of root folders declared as neither", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-jurisdiction", "title": "Taxonomy Jurisdiction" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [intent](/records/stage/intent)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean | ranking" ], "kind": "list" }, { "entries": [ { "description": "Score each governed container by how much reference surface a rename disturbs — importer count and the number of surfaces that resolve by pattern rather than by literal path — and rank ascending, so the pilot is the lowest-risk container and the highest-risk one lands last.", "term": "Intent" }, { "description": "The container converted first is the one whose failure is cheapest to detect, not the one whose naming is worst.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ContainerSet → ReferenceSurfaceCount → RiskScore → OrderedContainerQueue", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ReshapeRiskPriority ::= \"→\" \"→\" \nRiskScore ::= \"*\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Conversion starts wherever the tree looks worst, so the first container is the one with the most importers and the most pattern-resolved aggregators.", "kind": "code", "language": "text", "title": "Before" }, { "code": "containers → score(importer count x shape-discovered surface count) → ascending rank → pilot the lowest-risk container end to end first", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-reshape-risk-priority", "title": "Reshape Risk Priority" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [see](/records/stage/see)", "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Yields: edge-list" ], "kind": "list" }, { "entries": [ { "description": "Walk every governed path from its root, assign each folder depth a role from the declared grammar in the ordered sequence container then subject then concern, and emit the depth-to-role edge list together with the depths that repeat a role, revisit an earlier one, or exceed the cap.", "term": "Intent" }, { "description": "Each depth consumes a role strictly later than the depth before it, a role may be skipped but never repeated or revisited, and the file's parent always resolves to the concern role.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GovernedPath → DepthSequence → RoleAssignment → RoleEdgeList → DepthViolationSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "PathRoleWalk ::= \"→\" \"→\" \",\" \nRoleAssignment ::= \"<\" \"<\" \nDepthViolation ::= \"over_cap\" | \"role_repeated\" | \"role_revisited\" | \"file_outside_concern\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Bounded Nesting Depth](/records/architecture/bounded-nesting-depth)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A path is judged by whether it looks tidy, so a concern folder nested under a concern folder and a subject folder below its concern both read as ordinary nesting.", "kind": "code", "language": "text", "title": "Before" }, { "code": "path → assign each depth a role in the order container < subject < concern → depth<=cap and no role repeated or revisited → the role-assignment edge list plus the violating depths", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-path-role-walk", "title": "Path Role Walk" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Read each governed file, assign the narrowest accurate concern from the declared vocabulary by its primary responsibility, record a file that fits two concerns as a split candidate, and break an irreducible overlap by the domain-ward layer, so classification is judgment against the file rather than pattern-matching against its path.", "term": "Intent" }, { "description": "A concern is assigned by reading the file, never by its current location; a file that fits two concerns is a split candidate, not a tie to be broken arbitrarily.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "GovernedFile → PrimaryResponsibility → CandidateConcernSet → AssignedConcern → SplitCandidateSet", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ConcernClassification ::= \"→\" \"→\" \"|\" \nCandidateConcernSet ::= \"→\" \"+\"\nAssignedConcern ::= \"|\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [domain_boundary](/records/force/domain-boundary)", "term": "Forces" }, { "description": "[Narrowest Concern](/records/architecture/narrowest-concern)", "term": "Principle" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A file is tagged from where it currently sits, so a saturated label absorbs several distinct roles and a two-role file is hidden under whichever word came first.", "kind": "code", "language": "text", "title": "Before" }, { "code": "read the file → narrowest accurate declared concern → one concern: classified; two concerns: split candidate; irreducible overlap: domain-ward layer wins", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-concern-classification", "title": "Concern Classification" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Compose the target name from the assigned concern, the subject, and a variant taken only where a collision or a facet requires one, and derive the folder chain from that same concern, so the filename and its placement are one projection rather than two decisions.", "term": "Intent" }, { "description": "The concern tag terminates the filename and names the parent folder, so the name determines the placement and one unanchored pattern resolves either level.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "AssignedConcern → SubjectSelection → VariantTrigger → TargetName → TargetFolderChain", "kind": "code", "language": "text", "title": "Flow" }, { "code": "NameProjection ::= \",\" \",\" \"→\" \",\" \nTargetName ::= \".\" ? \".\" \".\" \nTargetFolderChain ::= \"/\" ? \"/\" \nVariantTrigger ::= \"collision\" | \"facet\" | \"none\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[Positional Slot Resolution](/records/architecture/positional-slot-resolution)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The new name is written by hand, so the tag lands mid-name, a compound swallows the concern, and the folder chain is chosen separately from the filename.", "kind": "code", "language": "text", "title": "Before" }, { "code": "(subject, variant?, concern, ext) → foo... with the tag terminating → the folder chain container/[subject]/ that the tag itself determines", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-name-projection", "title": "Name Projection" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [act](/records/stage/act)", "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Convert one container at a time: split the multi-role files first, move and rename each remaining file to its projected name and folder, update every importer in the same pass, move the mirrored tests to match the new concern folders, and re-point every surface whose pattern encoded the old form.", "term": "Intent" }, { "description": "A rename is one identity migration completed within a single container, references included; the gate is green before the next container starts.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "OrderedContainerQueue → SplitExecution → MoveRename → ImporterUpdate → TestMirrorMove → SurfaceRepoint", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContainerReshape ::= \"→\" \"→\" \"→\" \"→\" \nReferenceUpdate ::= \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A rename tool rewrites every literal path across the whole tree at once, and the surfaces that resolve by pattern are never re-pointed.", "kind": "code", "language": "text", "title": "Before" }, { "code": "one container → split candidates first → move and rename → update every importer → move the mirrored tests → re-point every shape-discovered surface → gate green before the next container", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-container-reshape", "title": "Container Reshape" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [constrain](/records/stage/constrain)", "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Hold every proposed word against the declared vocabularies and the rejection table, resolve and name the declared word that covers it where one does, refuse a word that names a process, an adjective, a grouping label, or a measurement, sort a surviving word by the is-a test into concerns or subjects, and admit it only by developer-approved registry edit.", "term": "Intent" }, { "description": "An undeclared word is a finding, never a license to add one, and a refusal names the covering word wherever the table resolves one; coverage is decided by the role a file plays, never by general-language synonymy.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ProposedWord → CoverageCheck → CoveringConcern → IsATest → AdmissionVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "VocabularyAdmissionGate ::= \"→\" \"→\" \"→\" \nCoverageCheck ::= \"→\" \"→\" \"|\" \"uncovered\"\nRejectionTableIndex ::= \"→\" \nAdmissionVerdict ::= \"admit_concern\" | \"admit_subject\" | \"refuse_rename_file\" | \"refuse_covered_by\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [model_governance](/records/force/model-governance)", "term": "Forces" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Principle" }, { "description": "[tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "An unclassifiable file is answered by adding its word to the vocabulary, or by an ignore entry, and the check goes green either way; where a word is refused, the refusal names only what is wrong.", "kind": "code", "language": "text", "title": "Before" }, { "code": "proposed word → rejection-table index resolves the covering concern: refuse naming it, and rename the file → uncovered: is-a a role: concerns; has-a a thing: subjects → otherwise refuse; admission is a developer-approved registry edit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-vocabulary-admission-gate", "title": "Vocabulary Admission Gate" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "For every shape-discovered surface touched by the reshape, compare the member set it collects against what it collected before, and issue the verdict from that comparison, so a collection that silently emptied is caught rather than read as a clean pass.", "term": "Intent" }, { "description": "A green gate is not evidence for a pattern-resolved surface; the verdict comes from the collected member set, and an unexplained drop is a failure.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ShapeDiscoveredSurfaceSet → CollectedSetBefore → CollectedSetAfter → DiscoveryVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DiscoveryVerification ::= \"→\" \"→\" \nCollectedSetDelta ::= \"-\" \nDiscoveryVerdict ::= \"preserved\" | \"intended_change\" | \"silently_emptied\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[Glob-Resolvable Tree](/records/architecture/glob-resolvable-tree)", "term": "Principle" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The gate is green after the rename, so the reshape is called done; the aggregator that collected by suffix now collects nothing and there is nothing left to check.", "kind": "code", "language": "text", "title": "Before" }, { "code": "per aggregator → collected member set before vs after → equal or intentionally changed: pass; silently emptied or shrunk: fail, and a green gate is not evidence", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-discovery-verification", "title": "Discovery Verification" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [commit](/records/stage/commit)", "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Yields: hash | novelty-score" ], "kind": "list" }, { "entries": [ { "description": "Record the registry version, the conversion state of each container, and every admitted and refused word with its reasoning, so the taxonomy's history is durable evidence rather than a fact re-derived from the tree on each pass.", "term": "Intent" }, { "description": "A refusal is recorded with its reason, so the answer to why a word is absent is retrievable rather than lost.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RegistryVersion → ContainerConversionState → AdmissionRecordSet → TaxonomyLedger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyLedger ::= \",\" \",\" \nAdmissionRecord ::= \",\" \",\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[observability_traceability](/records/force/observability-traceability), [architecture_evolution](/records/force/architecture-evolution)", "term": "Forces" }, { "description": "[Derived Naming Registry](/records/architecture/derived-naming-registry)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Which containers are converted and which words were refused is remembered rather than recorded, so the same rejected word is proposed again and the vocabulary drifts from the document.", "kind": "code", "language": "text", "title": "Before" }, { "code": "registry version + per-container conversion state + admitted and refused words → a durable ledger the next reshape and the next proposal both read", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-ledger", "title": "Taxonomy Ledger" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [terminate](/records/stage/terminate)", "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Mark the taxonomy complete only when every governed file resolves against the grammar at both levels, no split candidate is outstanding, and every shape-discovered surface has a preserved verdict, leaving it incomplete while any residual remains.", "term": "Intent" }, { "description": "Completion is the absence of residual findings, never a converted-container count, and never a finding removed by an ignore entry.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "TaxonomyLedger → ResidualFindingSet → CompletionVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyCompletion ::= \"→\" \"→\" \nResidualFindingSet ::= \"+\" \"+\" \"+\" \nCompletionVerdict ::= \"taxonomy_complete\" | \"taxonomy_incomplete\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Composed by" }, { "description": "[Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Named in the derivation of" }, { "description": "[correctness_verification](/records/force/correctness-verification), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Concern-Folder Correspondence](/records/architecture/concern-folder-correspondence)", "term": "Principle" }, { "description": "[ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "code": "Conversion is declared done on the container count, while unclassified files sit under an ignore entry and one aggregator still collects nothing.", "kind": "code", "language": "text", "title": "Before" }, { "code": "every governed file placed and named to the grammar AND every split candidate resolved AND every surface verified preserved → complete; any residual → incomplete", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-completion", "title": "Taxonomy Completion" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Decide what a folder found at a governed root is by asking, in order, whether it groups concern sets, holds one role, belongs under an existing container, or is not source at all, so a new container is declared only for a new grouping axis.", "term": "Intent" }, { "description": "A container is declared only for a grouping axis no existing container covers, and never to house a folder that resists placement or to shorten a path.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "RootFolder → SubjectTest → ConcernTest → ExistingContainerTest → SourceTest → LadderVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ContainerLadder ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nLadderVerdict ::= \"subject_folder\" | \"concern_folder\" | \"move_under_container\" | \"ignore_entry\" | \"propose_container\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[modularity](/records/force/modularity), [semantic_consistency](/records/force/semantic-consistency)", "term": "Forces" }, { "description": "[Declared Jurisdiction](/records/architecture/declared-jurisdiction)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A folder appears at a governed root, so it is declared a container, and the next folder that resists placement gets one too.", "kind": "code", "language": "text", "title": "Before" }, { "code": "folder at a root → groups concern sets that must not merge: subject folder → holds one role: concern folder → an existing container groups it: move it there → not source: ignore entry → only a new grouping axis: container, by approved edit", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-container-ladder", "title": "Container Ladder" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [derive](/records/stage/derive)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Give each export nothing imports the first verdict that holds, in order: wire it where a call site repeats its work, stage it as capability awaiting a consumer, delete a superseded one with its references, or remove it with the duplicate it served.", "term": "Intent" }, { "description": "An unreferenced export is triaged one at a time while its file is being read, and a report that nothing imports it starts the ladder rather than concluding it.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "UnreferencedExport → HandRolledCallSite → AwaitingConsumer → Superseded → ConsolidatedDuplicate → TriageVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "ExportTriageLadder ::= \"→\" \"→\" \"→\" \"→\" \"→\" \nTriageVerdict ::= \"wire\" | \"stage\" | \"delete\" | \"remove_with_duplicate\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[architecture_evolution](/records/force/architecture-evolution), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "The dead-code report lists exports nothing imports, and they are removed in bulk; a capability a call site was hand-rolling disappears with the evidence of the gap.", "kind": "code", "language": "text", "title": "Before" }, { "code": "unreferenced export → a call site hand-rolls it: wire it → capability awaiting a consumer: stage it in the allowlist → superseded with no consumer: delete with every reference → only consumer was a merged duplicate: remove with the duplicate", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-export-triage-ladder", "title": "Export Triage Ladder" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [project](/records/stage/project)", "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Yields: ordered-structure" ], "kind": "list" }, { "entries": [ { "description": "Resolve a filename whose extension a dialect names by splitting its stem at that case's word boundaries, taking the longest trailing word run that is a declared tag as the concern and the leading words as the subject and an optional declared variant.", "term": "Intent" }, { "description": "A dialect changes how the slots are spelled and never which words may fill them, so every dialect file resolves against the same closed vocabularies as a dotted one.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Extension → DialectCase → WordRun → ConcernRun → HeadSlots → ResolvedSlots", "kind": "code", "language": "text", "title": "Flow" }, { "code": "DialectResolution ::= \"→\" \"→\" \"→\" \",\" \"→\" \nDialectCase ::= \"camel\" | \"pascal\" | \"snake\" | \"kebab\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [contract_compatibility](/records/force/contract-compatibility)", "term": "Forces" }, { "description": "[Case Dialect](/records/architecture/case-dialect)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A language that names its files in another case is either left outside the grammar or forced into dotted names its own tools cannot find.", "kind": "code", "language": "text", "title": "Before" }, { "code": "extension → dialect case → stem split at word boundaries → longest trailing run that is a declared tag: concern → leading words: subject, then a declared variant → the same three slots the dotted grammar reads", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-dialect-resolution", "title": "Dialect Resolution" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Stage: [verify](/records/stage/verify)", "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)", "Yields: boolean" ], "kind": "list" }, { "entries": [ { "description": "Accept a conversion record only when the alignment entry it cites was written against the protocol's current revision and fewer than the declared span of records cite that entry, so the rules are re-read at a bounded cadence.", "term": "Intent" }, { "description": "Editing the protocol reopens every record written against the earlier revision, and no alignment entry covers more than the declared span of records.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "ConversionRecord → AlignmentEntry → RevisionCheck → SpanCheck → AlignmentVerdict", "kind": "code", "language": "text", "title": "Flow" }, { "code": "AlignmentCadence ::= \"→\" \"→\" \",\" \"→\" \nAlignmentVerdict ::= \"current\" | \"stale_revision\" | \"span_exceeded\"", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[correctness_verification](/records/force/correctness-verification), [observability_traceability](/records/force/observability-traceability)", "term": "Forces" }, { "description": "[Manual Identity Migration](/records/architecture/manual-identity-migration)", "term": "Principle" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "code": "A long conversion runs on a protocol read once at the start, and later files are classified under rulings that have faded from working context while every record still looks correct.", "kind": "code", "language": "text", "title": "Before" }, { "code": "conversion record → cites an alignment entry → the entry's hash equals the protocol's current hash and the run citing it is within the declared span → accepted; otherwise → re-read the protocol whole and write a new entry", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-alignment-cadence", "title": "Alignment Cadence" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Math type: [computation](/records/reasoning/math-type-computation)", "Yields: procedure" ], "kind": "list" }, { "entries": [ { "description": "Resolve jurisdiction from the registry, order the containers by reshape risk, walk each path into its ordered roles, classify each file to its narrowest concern, project the name and the folder chain together, reshape one container at a time, hold every proposed word at the admission gate, verify that pattern-resolved surfaces still collect what they collected, ledger the state, and terminate only when no residual finding remains.", "term": "Intent" }, { "description": "Placement and naming are one derivation from a declared vocabulary to a verified tree, in which every folder and every filename slot resolves to a declared word and one unanchored pattern resolves a concern at either level.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Jurisdiction → RiskPriority → RoleWalk → Classification → NameProjection → Reshape → AdmissionGate → DiscoveryVerification → Ledger → Completion", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyKernel ::= \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Path Role Walk](/records/algorithms/path-role-walk), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Reshape](/records/algorithms/container-reshape), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [modularity](/records/force/modularity), [architecture_evolution](/records/force/architecture-evolution), [correctness_verification](/records/force/correctness-verification)", "term": "Forces" }, { "description": "[Closed Vocabulary](/records/architecture/closed-vocabulary)", "term": "Principle" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "Derivation map" }, { "entries": [ { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)", "term": "orient" }, { "description": "[Reshape Risk Priority](/records/algorithms/reshape-risk-priority)", "term": "intent" }, { "description": "[Path Role Walk](/records/algorithms/path-role-walk)", "term": "see" }, { "description": "[Concern Classification](/records/algorithms/concern-classification)", "term": "derive" }, { "description": "[Name Projection](/records/algorithms/name-projection)", "term": "project" }, { "description": "[Container Reshape](/records/algorithms/container-reshape)", "term": "act" }, { "description": "[Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)", "term": "constrain" }, { "description": "[Discovery Verification](/records/algorithms/discovery-verification)", "term": "verify" }, { "description": "[Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "commit" }, { "description": "[Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "terminate" } ], "kind": "glossary" }, { "code": "Naming and placement are conventions carried in reviewers' heads, so a path has more than one right answer, an undeclared word enters whenever a file resists classification, and no pattern resolves a concern tree-wide.", "kind": "code", "language": "text", "title": "Before" }, { "code": "jurisdiction → risk priority → role walk → classification → name projection → container reshape → admission gate → discovery verification → ledger → completion", "kind": "code", "language": "text", "title": "After" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "[Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Path Role Walk](/records/algorithms/path-role-walk), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Reshape](/records/algorithms/container-reshape), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-kernel", "title": "Taxonomy Kernel" }, { "blocks": [ { "items": [ "Domain: [taxonomy](/records/algorithms-domain/taxonomy)", "Tier: [process](/records/vocabulary/domain-tier-process)", "Meta record" ], "kind": "list" }, { "entries": [ { "description": " → → → → → → → → → ", "term": "Intent" }, { "description": "Every governed folder and every filename slot resolves to a word from a closed declared vocabulary, the concern tag terminates the filename and names its parent folder, and no path exceeds the declared depth cap.", "term": "Invariant" } ], "kind": "glossary" }, { "code": "Jurisdiction → RoleWalk → Classification → NameProjection → Reshape → AdmissionGate → Verification → Ledger", "kind": "code", "language": "text", "title": "Flow" }, { "code": "TaxonomyConcern ::= \"→\" \"→\" \"→\" \",\" \"→\" \"→\" ", "kind": "code", "language": "bnf", "title": "Productions" }, { "entries": [ { "description": "none", "term": "Composes" }, { "description": "[semantic_consistency](/records/force/semantic-consistency), [modularity](/records/force/modularity)", "term": "Forces" }, { "description": "none", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the placement and naming gates, the discovery verification, which compares what each pattern-resolved surface collects before and after a rename", "term": "Checked by" }, { "description": "Every file and folder under a declared governed root", "term": "Population" }, { "description": "A verdict stands until a file is created, moved or renamed, or the vocabulary changes", "term": "Freshness" }, { "description": "The lint stage fails an undeclared word, a tag that does not match its folder, or a path over the depth cap", "term": "Refusal" }, { "description": "None, because placement is decided on the tree", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite lints a file whose tag is undeclared and one whose tag differs from its folder, another refuses a repeated role and a path past the depth cap, and both pass conforming paths", "term": "Evidence" }, { "description": "The declared vocabularies and roots, which every path conforms to, so an undeclared word is an approved edit to the declaration", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "algorithms-taxonomy-concern", "title": "" } ], "title": "Taxonomy" } ] }, { "icon": "bi-compass", "id": "reasoning", "label": "Reasoning", "layout": "ontology", "sections": [ { "blocks": [ { "caption": "The derivation loop with its gates.", "kind": "mermaid", "text": "flowchart TB\n n_orient[\"orient · ontology\"]\n n_intent[\"intent · teleology\"]\n n_see[\"see · analysis\"]\n n_derive[\"derive · reasoning\"]\n n_project[\"project · reasoning\"]\n n_act[\"act · formalization\"]\n n_constrain[\"constrain · teleology\"]\n n_verify[\"verify · verification\"]\n n_commit[\"commit · representation\"]\n n_terminate[\"terminate · termination\"]\n n_orient --> n_intent\n n_intent -- tel-priority --> n_see\n n_see --> n_derive\n n_derive --> n_project\n n_project --> n_act\n n_act --> n_constrain\n n_constrain --> n_verify\n n_verify -.-> n_derive\n n_verify --> n_commit\n n_commit --> n_terminate\n n_terminate --> n_orient" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "icon": "bi-signpost-split", "id": "reasoning-loop-derivation-loop", "intro": "Every algorithm grammar is an instance of the derivation loop, which has ten stages, each on one reasoning axis, joined by transitions that sequence, gate or refute back. Each stage is listed with the contracts that run at it and the records it grounds, and the traversal is taught in [the loop](/disciplined-methodology#the-loop) on the methodology page.", "subsections": [ { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)" ], "kind": "list" }, { "entries": [ { "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Capability Profile](/records/algorithms/capability-profile), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Capability Disclosure](/records/algorithms/capability-disclosure), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Context Initialization](/records/algorithms/context-initialization), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Coverage Workspace](/records/algorithms/coverage-workspace), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-orient", "title": "orient" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)" ], "kind": "list" }, { "entries": [ { "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-intent", "title": "intent" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)" ], "kind": "list" }, { "entries": [ { "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Scalability Projection](/records/algorithms/scalability-projection), [Research Guidance](/records/algorithms/research-guidance), [Tool Calibration](/records/algorithms/tool-calibration), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Path Role Walk](/records/algorithms/path-role-walk)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-see", "title": "see" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)" ], "kind": "list" }, { "entries": [ { "description": "[Principle Extraction](/records/algorithms/principle-extraction), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Violation Classification](/records/algorithms/violation-classification), [Invocation Join](/records/algorithms/invocation-join), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Concern Classification](/records/algorithms/concern-classification), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-derive", "title": "derive" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)" ], "kind": "list" }, { "entries": [ { "description": "[Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Severity Assignment](/records/algorithms/severity-assignment), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Stage Ordering](/records/algorithms/stage-ordering), [Name Projection](/records/algorithms/name-projection), [Dialect Resolution](/records/algorithms/dialect-resolution)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-project", "title": "project" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)" ], "kind": "list" }, { "entries": [ { "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Compilation Stage](/records/algorithms/compilation-stage), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Recursion Control](/records/algorithms/recursion-control), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Test Authoring](/records/algorithms/test-authoring), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Container Reshape](/records/algorithms/container-reshape)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-act", "title": "act" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)" ], "kind": "list" }, { "entries": [ { "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Replacement Safety](/records/algorithms/replacement-safety), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)", "term": "Contracts" }, { "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-constrain", "title": "constrain" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)" ], "kind": "list" }, { "entries": [ { "description": "[Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Validation Score](/records/algorithms/validation-score), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Verification Loop](/records/algorithms/verification-loop), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Distillation Metrics](/records/algorithms/distillation-metrics), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [Alignment Cadence](/records/algorithms/alignment-cadence)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-verify", "title": "verify" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)" ], "kind": "list" }, { "entries": [ { "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Convergence Walk](/records/algorithms/convergence-walk), [Coverage Ledger](/records/algorithms/coverage-ledger), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-commit", "title": "commit" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)" ], "kind": "list" }, { "entries": [ { "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Early Success Exit](/records/algorithms/early-success-exit), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis", "term": "Checked by" }, { "description": "Every process grammar, its kernel and its staged records", "term": "Population" }, { "description": "A verdict stands until the loop, a grammar or a staged record changes", "term": "Freshness" }, { "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage", "term": "Refusal" }, { "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record", "term": "Evidence" }, { "description": "The loop's stage list, which every kernel and staged record cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "stage-terminate", "title": "terminate" }, { "blocks": [ { "entries": [ { "description": "[orient](/records/stage/orient) → [intent](/records/stage/intent) · Transition: sequences", "term": "orient → intent" }, { "description": "[intent](/records/stage/intent) → [see](/records/stage/see) · Transition: gates · Gate: tel-priority · On fail: redirect", "term": "intent → see" }, { "description": "[see](/records/stage/see) → [derive](/records/stage/derive) · Transition: sequences", "term": "see → derive" }, { "description": "[derive](/records/stage/derive) → [project](/records/stage/project) · Transition: sequences", "term": "derive → project" }, { "description": "[project](/records/stage/project) → [act](/records/stage/act) · Transition: sequences", "term": "project → act" }, { "description": "[act](/records/stage/act) → [constrain](/records/stage/constrain) · Transition: sequences", "term": "act → constrain" }, { "description": "[constrain](/records/stage/constrain) → [verify](/records/stage/verify) · Transition: sequences", "term": "constrain → verify" }, { "description": "[verify](/records/stage/verify) → [derive](/records/stage/derive) · Transition: refutes-back · Gate: ver-evidence · On fail: derive", "term": "verify → derive" }, { "description": "[verify](/records/stage/verify) → [commit](/records/stage/commit) · Transition: sequences", "term": "verify → commit" }, { "description": "[commit](/records/stage/commit) → [terminate](/records/stage/terminate) · Transition: sequences", "term": "commit → terminate" }, { "description": "[terminate](/records/stage/terminate) → [orient](/records/stage/orient) · Transition: sequences · Gate: ter-stop · On pass: stop", "term": "terminate → orient" } ], "kind": "glossary" } ], "title": "The transitions" } ], "title": "The derivation loop" }, { "blocks": [ { "caption": "The substrate cycle and its recursion.", "kind": "mermaid", "text": "flowchart LR\n n_existence[\"existence\"]\n n_difference[\"difference\"]\n n_relation[\"relation\"]\n n_structure[\"structure\"]\n n_transformation[\"transformation\"]\n n_constraint[\"constraint\"]\n n_emergence[\"emergence\"]\n n_existence --> n_difference\n n_difference --> n_relation\n n_relation --> n_structure\n n_structure --> n_transformation\n n_transformation --> n_constraint\n n_constraint --> n_emergence\n n_emergence -.-> n_difference" }, { "kind": "text", "text": "Recursion · [emergence](/records/reasoning/substrate-node-emergence) → [difference](/records/reasoning/substrate-node-difference)" } ], "icon": "bi-signpost-split", "id": "the-substrate", "intro": "Beneath the loop lies the generative substrate, meaning the cycle every node passes through, the recursion that turns emergence back into a new difference, and the math types each node yields.", "subsections": [ { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-existence", "title": "Existence" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-difference", "title": "Difference" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [graph](/records/reasoning/math-type-graph)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-relation", "title": "Relation" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [algebra](/records/reasoning/math-type-algebra)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-structure", "title": "Structure" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [analysis](/records/reasoning/math-type-analysis)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-transformation", "title": "Transformation" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-constraint", "title": "Constraint" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [topology](/records/reasoning/math-type-topology)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-invariant", "title": "Invariant" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [probability](/records/reasoning/math-type-probability)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-uncertainty", "title": "Uncertainty" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-information", "title": "Information" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [computation](/records/reasoning/math-type-computation)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-procedure", "title": "Procedure" }, { "blocks": [ { "items": [ "Layer: [Substrate](/records/reasoning/layer-substrate)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)" ], "kind": "list" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node", "term": "Checked by" }, { "description": "Every model, document construct and genesis tag that names the substrate node", "term": "Population" }, { "description": "A verdict stands until the substrate or a record that names one of its nodes changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a substrate node that does not exist", "term": "Refusal" }, { "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean", "term": "Evidence" }, { "description": "The substrate node list, which every step, math type, tag and construct that names a node cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-substrate-node-emergence", "title": "Emergence" } ], "title": "The substrate" }, { "icon": "bi-signpost-split", "id": "the-reasoning-layers", "intro": "The reasoning axes are arranged on these layers, each listed with the question it answers and the axes it holds.", "subsections": [ { "blocks": [ { "entries": [ { "description": "How does anything come to be?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve", "term": "Checked by" }, { "description": "Every axis and substrate node that names the layer", "term": "Population" }, { "description": "A verdict stands until the layer list or a record that names a layer changes", "term": "Freshness" }, { "description": "The gate fails on an axis or substrate node that names a layer that does not exist", "term": "Refusal" }, { "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve", "term": "Evidence" }, { "description": "The layer list, which every axis and substrate node that names a layer cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-layer-substrate", "title": "Substrate" }, { "blocks": [ { "entries": [ { "description": "How is it known?", "term": "Question" }, { "description": "[ontology](/records/reasoning/axis-ontology), [analysis](/records/reasoning/axis-analysis), [reasoning](/records/reasoning/axis-reasoning), [representation](/records/reasoning/axis-representation), [formalization](/records/reasoning/axis-formalization)", "term": "Axes" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve", "term": "Checked by" }, { "description": "Every axis and substrate node that names the layer", "term": "Population" }, { "description": "A verdict stands until the layer list or a record that names a layer changes", "term": "Freshness" }, { "description": "The gate fails on an axis or substrate node that names a layer that does not exist", "term": "Refusal" }, { "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve", "term": "Evidence" }, { "description": "The layer list, which every axis and substrate node that names a layer cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-layer-epistemic", "title": "Epistemic" }, { "blocks": [ { "entries": [ { "description": "What is worth doing?", "term": "Question" }, { "description": "[teleology](/records/reasoning/axis-teleology)", "term": "Axes" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve", "term": "Checked by" }, { "description": "Every axis and substrate node that names the layer", "term": "Population" }, { "description": "A verdict stands until the layer list or a record that names a layer changes", "term": "Freshness" }, { "description": "The gate fails on an axis or substrate node that names a layer that does not exist", "term": "Refusal" }, { "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve", "term": "Evidence" }, { "description": "The layer list, which every axis and substrate node that names a layer cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-layer-conative", "title": "Conative" }, { "blocks": [ { "entries": [ { "description": "Is it right, and is it done?", "term": "Question" }, { "description": "[verification](/records/reasoning/axis-verification), [termination](/records/reasoning/axis-termination)", "term": "Axes" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve", "term": "Checked by" }, { "description": "Every axis and substrate node that names the layer", "term": "Population" }, { "description": "A verdict stands until the layer list or a record that names a layer changes", "term": "Freshness" }, { "description": "The gate fails on an axis or substrate node that names a layer that does not exist", "term": "Refusal" }, { "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve", "term": "Evidence" }, { "description": "The layer list, which every axis and substrate node that names a layer cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-layer-evaluative", "title": "Evaluative" } ], "title": "The reasoning layers" }, { "icon": "bi-signpost-split", "id": "the-axes", "intro": "Each reasoning axis is a typed, terminating question on one layer, listed with the nodes a run may select on it and the contracts positioned on it.", "subsections": [ { "blocks": [ { "items": [ "Layer: [Epistemic](/records/reasoning/layer-epistemic)", "Mandatory: when-relevant", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Selectable: yes" ], "kind": "list" }, { "entries": [ { "description": "What is it?", "term": "Question" }, { "description": "[ont-identity](/records/reasoning/node-ont-identity), [ont-composition](/records/reasoning/node-ont-composition), [ont-structure](/records/reasoning/node-ont-structure), [ont-relation](/records/reasoning/node-ont-relation), [ont-space](/records/reasoning/node-ont-space), [ont-time](/records/reasoning/node-ont-time), [ont-state](/records/reasoning/node-ont-state), [ont-change](/records/reasoning/node-ont-change), [ont-behavior](/records/reasoning/node-ont-behavior), [ont-function](/records/reasoning/node-ont-function), [ont-cause](/records/reasoning/node-ont-cause), [ont-meaning](/records/reasoning/node-ont-meaning), [ont-scale](/records/reasoning/node-ont-scale), [ont-probability](/records/reasoning/node-ont-probability), [ont-novelty](/records/reasoning/node-ont-novelty)", "term": "Nodes" }, { "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Capability Profile](/records/algorithms/capability-profile), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Capability Disclosure](/records/algorithms/capability-disclosure), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Context Initialization](/records/algorithms/context-initialization), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Coverage Workspace](/records/algorithms/coverage-workspace), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-ontology", "title": "ontology" }, { "blocks": [ { "items": [ "Layer: [Epistemic](/records/reasoning/layer-epistemic)", "Mandatory: when-relevant", "Math type: [graph](/records/reasoning/math-type-graph)", "Selectable: yes" ], "kind": "list" }, { "entries": [ { "description": "How is it to be seen?", "term": "Question" }, { "description": "[ana-structural](/records/reasoning/node-ana-structural), [ana-temporal](/records/reasoning/node-ana-temporal), [ana-spatial](/records/reasoning/node-ana-spatial), [ana-statistical](/records/reasoning/node-ana-statistical), [ana-frequency](/records/reasoning/node-ana-frequency), [ana-sequential](/records/reasoning/node-ana-sequential), [ana-relational](/records/reasoning/node-ana-relational), [ana-behavioral](/records/reasoning/node-ana-behavioral), [ana-functional](/records/reasoning/node-ana-functional), [ana-semantic](/records/reasoning/node-ana-semantic), [ana-causal](/records/reasoning/node-ana-causal), [ana-predictive](/records/reasoning/node-ana-predictive), [ana-anomaly](/records/reasoning/node-ana-anomaly), [ana-evolutionary](/records/reasoning/node-ana-evolutionary), [ana-fractal](/records/reasoning/node-ana-fractal)", "term": "Nodes" }, { "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Scalability Projection](/records/algorithms/scalability-projection), [Research Guidance](/records/algorithms/research-guidance), [Tool Calibration](/records/algorithms/tool-calibration), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Path Role Walk](/records/algorithms/path-role-walk)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-analysis", "title": "analysis" }, { "blocks": [ { "items": [ "Layer: [Epistemic](/records/reasoning/layer-epistemic)", "Mandatory: when-relevant", "Math type: [logic](/records/reasoning/math-type-logic)", "Selectable: yes" ], "kind": "list" }, { "entries": [ { "description": "Why, and what follows?", "term": "Question" }, { "description": "[rea-observation](/records/reasoning/node-rea-observation), [rea-description](/records/reasoning/node-rea-description), [rea-comparison](/records/reasoning/node-rea-comparison), [rea-classification](/records/reasoning/node-rea-classification), [rea-explanation](/records/reasoning/node-rea-explanation), [rea-prediction](/records/reasoning/node-rea-prediction), [rea-intervention](/records/reasoning/node-rea-intervention), [rea-creation](/records/reasoning/node-rea-creation), [rea-reflection](/records/reasoning/node-rea-reflection)", "term": "Nodes" }, { "description": "[Principle Extraction](/records/algorithms/principle-extraction), [Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Severity Assignment](/records/algorithms/severity-assignment), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Violation Classification](/records/algorithms/violation-classification), [Invocation Join](/records/algorithms/invocation-join), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder), [Dialect Resolution](/records/algorithms/dialect-resolution)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-reasoning", "title": "reasoning" }, { "blocks": [ { "items": [ "Layer: [Epistemic](/records/reasoning/layer-epistemic)", "Mandatory: when-relevant", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Selectable: yes" ], "kind": "list" }, { "entries": [ { "description": "How is it encoded?", "term": "Question" }, { "description": "[rep-symbolic](/records/reasoning/node-rep-symbolic), [rep-numerical](/records/reasoning/node-rep-numerical), [rep-geometric](/records/reasoning/node-rep-geometric), [rep-topological](/records/reasoning/node-rep-topological), [rep-information-theoretic](/records/reasoning/node-rep-information-theoretic), [rep-probabilistic](/records/reasoning/node-rep-probabilistic), [rep-dynamical](/records/reasoning/node-rep-dynamical), [rep-computational](/records/reasoning/node-rep-computational)", "term": "Nodes" }, { "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Convergence Walk](/records/algorithms/convergence-walk), [Coverage Ledger](/records/algorithms/coverage-ledger), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-representation", "title": "representation" }, { "blocks": [ { "items": [ "Layer: [Epistemic](/records/reasoning/layer-epistemic)", "Mandatory: when-relevant", "Math type: [computation](/records/reasoning/math-type-computation)", "Selectable: yes" ], "kind": "list" }, { "entries": [ { "description": "What does it resolve to?", "term": "Question" }, { "description": "[for-existence](/records/reasoning/node-for-existence), [for-structure](/records/reasoning/node-for-structure), [for-relation](/records/reasoning/node-for-relation), [for-space](/records/reasoning/node-for-space), [for-transformation](/records/reasoning/node-for-transformation), [for-invariance](/records/reasoning/node-for-invariance), [for-uncertainty](/records/reasoning/node-for-uncertainty), [for-computation](/records/reasoning/node-for-computation), [for-abstraction](/records/reasoning/node-for-abstraction), [for-creation](/records/reasoning/node-for-creation), [for-absence](/records/reasoning/node-for-absence)", "term": "Nodes" }, { "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Compilation Stage](/records/algorithms/compilation-stage), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Recursion Control](/records/algorithms/recursion-control), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Test Authoring](/records/algorithms/test-authoring), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Container Reshape](/records/algorithms/container-reshape)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-formalization", "title": "formalization" }, { "blocks": [ { "items": [ "Layer: [Conative](/records/reasoning/layer-conative)", "Mandatory: always", "Math type: [optimization](/records/reasoning/math-type-optimization)", "Selectable: no" ], "kind": "list" }, { "entries": [ { "description": "What is it for?", "term": "Question" }, { "description": "[tel-objective](/records/reasoning/node-tel-objective), [tel-utility](/records/reasoning/node-tel-utility), [tel-cost](/records/reasoning/node-tel-cost), [tel-priority](/records/reasoning/node-tel-priority)", "term": "Nodes" }, { "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Replacement Safety](/records/algorithms/replacement-safety), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-teleology", "title": "teleology" }, { "blocks": [ { "items": [ "Layer: [Evaluative](/records/reasoning/layer-evaluative)", "Mandatory: always", "Math type: [logic](/records/reasoning/math-type-logic)", "Selectable: no" ], "kind": "list" }, { "entries": [ { "description": "Is it real?", "term": "Question" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence), [ver-ground-truth](/records/reasoning/node-ver-ground-truth), [ver-falsification](/records/reasoning/node-ver-falsification), [ver-confidence](/records/reasoning/node-ver-confidence), [ver-refutation](/records/reasoning/node-ver-refutation), [ver-population](/records/reasoning/node-ver-population), [ver-freshness](/records/reasoning/node-ver-freshness), [ver-standing](/records/reasoning/node-ver-standing), [ver-refusal](/records/reasoning/node-ver-refusal), [ver-observation](/records/reasoning/node-ver-observation)", "term": "Nodes" }, { "description": "[Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Validation Score](/records/algorithms/validation-score), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Verification Loop](/records/algorithms/verification-loop), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Distillation Metrics](/records/algorithms/distillation-metrics), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [Alignment Cadence](/records/algorithms/alignment-cadence)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-verification", "title": "verification" }, { "blocks": [ { "items": [ "Layer: [Evaluative](/records/reasoning/layer-evaluative)", "Mandatory: always", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Selectable: no" ], "kind": "list" }, { "entries": [ { "description": "Is it done?", "term": "Question" }, { "description": "[ter-completion](/records/reasoning/node-ter-completion), [ter-saturation](/records/reasoning/node-ter-saturation), [ter-diminishing-returns](/records/reasoning/node-ter-diminishing-returns), [ter-block](/records/reasoning/node-ter-block), [ter-stop](/records/reasoning/node-ter-stop), [ter-promotion](/records/reasoning/node-ter-promotion), [ter-publication](/records/reasoning/node-ter-publication)", "term": "Nodes" }, { "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Early Success Exit](/records/algorithms/early-success-exit), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve", "term": "Checked by" }, { "description": "Every reasoning node, loop stage and algorithm record that names the axis", "term": "Population" }, { "description": "A verdict stands until the axis list or a record that names an axis changes", "term": "Freshness" }, { "description": "The gate fails on a node, stage or ground that names an axis that does not exist", "term": "Refusal" }, { "description": "None, because an axis is a category of question, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean", "term": "Evidence" }, { "description": "The axis list, which every node, stage and ground that names an axis cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-axis-termination", "title": "termination" } ], "title": "The axes" }, { "icon": "bi-signpost-split", "id": "the-nodes", "intro": "Every node on the axes is listed with the concept it resolves to, the question it asks, the math type it yields, the shape of its answer, its decision test and its role, and the surfaces and contracts that ground themselves in it.", "subsections": [ { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Concept: [identity](/records/reasoning/dimension-identity)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-identity", "title": "Identity" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Concept: [composition](/records/reasoning/dimension-composition)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-composition", "title": "Composition" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Concept: [structure](/records/reasoning/dimension-structure)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-structure", "title": "Structure" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [graph](/records/reasoning/math-type-graph)", "Concept: [relation](/records/reasoning/dimension-relation)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-relation", "title": "Relation" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [space](/records/reasoning/dimension-space)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-space", "title": "Space" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [time](/records/reasoning/dimension-time)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-time", "title": "Time" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Concept: [state](/records/reasoning/dimension-state)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-state", "title": "State" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [change](/records/reasoning/dimension-change)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-change", "title": "Change" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Concept: [behavior](/records/reasoning/dimension-behavior)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-behavior", "title": "Behavior" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [function](/records/reasoning/dimension-function)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-function", "title": "Function" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [cause](/records/reasoning/dimension-cause)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-cause", "title": "Cause" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [logic](/records/reasoning/math-type-logic)", "Concept: [meaning](/records/reasoning/dimension-meaning)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-meaning", "title": "Meaning" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [scale](/records/reasoning/dimension-scale)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-scale", "title": "Scale" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [probability](/records/reasoning/dimension-probability)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-probability", "title": "Probability" }, { "blocks": [ { "items": [ "Axis: [ontology](/records/reasoning/axis-ontology)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [novelty](/records/reasoning/dimension-novelty)" ], "kind": "list" }, { "entries": [ { "description": "[Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ont-novelty", "title": "Novelty" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Concept: [structural](/records/reasoning/lens-structure)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-structural", "title": "Structural Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [temporal](/records/reasoning/lens-time)" ], "kind": "list" }, { "entries": [ { "description": "[Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-temporal", "title": "Temporal Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [spatial](/records/reasoning/lens-space)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-spatial", "title": "Spatial Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [statistical](/records/reasoning/lens-statistical)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-statistical", "title": "Statistical Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Concept: [frequency](/records/reasoning/lens-frequency)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-frequency", "title": "Frequency Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [logic](/records/reasoning/math-type-logic)", "Concept: [sequential](/records/reasoning/lens-sequential)" ], "kind": "list" }, { "entries": [ { "description": "[Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-sequential", "title": "Sequential Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [graph](/records/reasoning/math-type-graph)", "Concept: [relational](/records/reasoning/lens-relation)" ], "kind": "list" }, { "entries": [ { "description": "[Relational Graph Duplication](/records/algorithms/relational-graph-duplication)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-relational", "title": "Relational Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Concept: [behavioral](/records/reasoning/lens-behavior)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-behavioral", "title": "Behavioral Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [functional](/records/reasoning/lens-function)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-functional", "title": "Functional Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [logic](/records/reasoning/math-type-logic)", "Concept: [semantic](/records/reasoning/lens-meaning)" ], "kind": "list" }, { "entries": [ { "description": "[Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-semantic", "title": "Semantic Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [causal](/records/reasoning/lens-cause)" ], "kind": "list" }, { "entries": [ { "description": "[Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-causal", "title": "Causal Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [predictive](/records/reasoning/lens-prediction)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-predictive", "title": "Predictive Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [anomaly](/records/reasoning/lens-anomaly)" ], "kind": "list" }, { "entries": [ { "description": "[Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-anomaly", "title": "Anomaly Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Concept: [evolutionary](/records/reasoning/lens-change)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-evolutionary", "title": "Evolutionary Analysis" }, { "blocks": [ { "items": [ "Axis: [analysis](/records/reasoning/axis-analysis)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [fractal](/records/reasoning/lens-fractal)" ], "kind": "list" }, { "entries": [ { "description": "[Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ana-fractal", "title": "Fractal Analysis" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Concept: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-observation", "title": "Observation" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Concept: [description](/records/reasoning/mode-description)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-description", "title": "Description" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [logic](/records/reasoning/math-type-logic)", "Concept: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-comparison", "title": "Comparison" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)", "Concept: [classification](/records/reasoning/mode-classification)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-classification", "title": "Classification" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [explanation](/records/reasoning/mode-explanation)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-explanation", "title": "Explanation" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [prediction](/records/reasoning/mode-prediction)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-prediction", "title": "Prediction" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [analysis](/records/reasoning/math-type-analysis)", "Concept: [intervention](/records/reasoning/mode-intervention)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-intervention", "title": "Intervention" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [computation](/records/reasoning/math-type-computation)", "Concept: [creation](/records/reasoning/mode-creation)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-creation", "title": "Creation" }, { "blocks": [ { "items": [ "Axis: [reasoning](/records/reasoning/axis-reasoning)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [reflection](/records/reasoning/mode-reflection)" ], "kind": "list" }, { "entries": [], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rea-reflection", "title": "Reflection" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [algebra](/records/reasoning/math-type-algebra)", "Concept: [symbolic](/records/reasoning/representation-symbolic)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as equations or notation?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-symbolic", "title": "Symbolic Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [numerical](/records/reasoning/representation-number)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as quantities?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-numerical", "title": "Numerical Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [geometric](/records/reasoning/representation-geometry)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as shapes or coordinates?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-geometric", "title": "Geometric Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [topology](/records/reasoning/math-type-topology)", "Concept: [topological](/records/reasoning/representation-topology)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as connectivity or continuity?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-topological", "title": "Topological Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)", "Concept: [information-theoretic](/records/reasoning/representation-information-theory)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as entropy or compression?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-information-theoretic", "title": "Information-Theoretic Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [probability](/records/reasoning/math-type-probability)", "Concept: [probabilistic](/records/reasoning/representation-probability)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as distributions?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-probabilistic", "title": "Probabilistic Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)", "Concept: [dynamical](/records/reasoning/representation-dynamical-systems)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as state transitions?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-dynamical", "title": "Dynamical Representation" }, { "blocks": [ { "items": [ "Axis: [representation](/records/reasoning/axis-representation)", "Math type: [computation](/records/reasoning/math-type-computation)", "Concept: [computational](/records/reasoning/representation-computation)" ], "kind": "list" }, { "entries": [ { "description": "Is it encoded as an algorithm?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-rep-computational", "title": "Computational Representation" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "What object exists?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-existence", "title": "Existence" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [algebra](/records/reasoning/math-type-algebra)" ], "kind": "list" }, { "entries": [ { "description": "What structure holds?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-structure", "title": "Formal Structure" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [graph](/records/reasoning/math-type-graph)" ], "kind": "list" }, { "entries": [ { "description": "What mapping connects objects?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-relation", "title": "Mapping" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [topology](/records/reasoning/math-type-topology)" ], "kind": "list" }, { "entries": [ { "description": "What environment contains them?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-space", "title": "Environment" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [analysis](/records/reasoning/math-type-analysis)" ], "kind": "list" }, { "entries": [ { "description": "What operation applies?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-transformation", "title": "Transformation" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [topology](/records/reasoning/math-type-topology)" ], "kind": "list" }, { "entries": [ { "description": "What is preserved?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-invariance", "title": "Invariance" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [probability](/records/reasoning/math-type-probability)" ], "kind": "list" }, { "entries": [ { "description": "What is uncertain?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-uncertainty", "title": "Uncertainty" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)" ], "kind": "list" }, { "entries": [ { "description": "What is computable?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-computation", "title": "Computability" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [topology](/records/reasoning/math-type-topology)" ], "kind": "list" }, { "entries": [ { "description": "What generalizes?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-abstraction", "title": "Abstraction" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [computation](/records/reasoning/math-type-computation)" ], "kind": "list" }, { "entries": [ { "description": "What new structure can emerge?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-creation", "title": "Emergence" }, { "blocks": [ { "items": [ "Axis: [formalization](/records/reasoning/axis-formalization)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "What is absent, and is it distinguished from unknown, omitted and zero?", "term": "Question" }, { "description": "set", "term": "Answer shape" }, { "description": "every absence a later check must distinguish is represented as its own value", "term": "Decision test" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-for-absence", "title": "Absence" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "entries": [ { "description": "What is the objective?", "term": "Question" }, { "description": "[meta_block](/records/pag/production-meta-block), [meta_field](/records/pag/production-meta-field), [node_meta_tag](/records/pag/production-node-meta-tag)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-tel-objective", "title": "Objective" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "entries": [ { "description": "How much does this advance the objective?", "term": "Question" }, { "description": "number", "term": "Answer shape" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-tel-utility", "title": "Branch Utility" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "entries": [ { "description": "What does this cost?", "term": "Question" }, { "description": "number", "term": "Answer shape" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-tel-cost", "title": "Branch Cost" }, { "blocks": [ { "items": [ "Axis: [teleology](/records/reasoning/axis-teleology)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "entries": [ { "description": "Is this the highest-worth admissible branch?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "the branch has the highest utility minus cost among the admissible branches", "term": "Decision test" }, { "description": "injection-gate", "term": "Role" }, { "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity Assignment](/records/algorithms/severity-assignment), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [priority_queue_declaration](/records/pag/production-priority-queue-declaration)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-tel-priority", "title": "Branch Priority" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "What evidence supports this?", "term": "Question" }, { "description": "set", "term": "Answer shape" }, { "description": "the evidence set is non-empty", "term": "Decision test" }, { "description": "both", "term": "Role" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [handoff_gate](/records/pag/production-handoff-gate), [check_line](/records/pag/production-check-line), [check_marker](/records/pag/production-check-marker), [report_block](/records/pag/production-report-block)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-evidence", "title": "Evidence" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "Is it true against reality, not merely coherent?", "term": "Question" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-ground-truth", "title": "Ground Truth" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "What would refute it?", "term": "Question" }, { "description": "[invariant_record](/records/pag/production-invariant-record)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-falsification", "title": "Refutation Condition" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [probability](/records/reasoning/math-type-probability)" ], "kind": "list" }, { "entries": [ { "description": "How confident is it, and is that enough?", "term": "Question" }, { "description": "number[0,1]", "term": "Answer shape" }, { "description": "confidence is at or above the threshold", "term": "Decision test" }, { "description": "[verdict](/records/pag/production-verdict)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-confidence", "title": "Confidence" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "Does refutation outweigh support?", "term": "Question" }, { "description": "[result_line](/records/pag/production-result-line), [repair_edge](/records/pag/production-repair-edge)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-refutation", "title": "Support Against Refutation" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Over what set was this checked?", "term": "Question" }, { "description": "ratio", "term": "Answer shape" }, { "description": "the declared population is non-empty and every member is measured or named absent", "term": "Decision test" }, { "description": "both", "term": "Role" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [population_clause](/records/pag/production-population-clause), [report_field](/records/pag/production-report-field)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-population", "title": "Population" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [information-theory](/records/reasoning/math-type-information-theory)" ], "kind": "list" }, { "entries": [ { "description": "Was the read derived after the last relevant mutator?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "the fingerprint of the inputs and the code matches the output's declared derivation", "term": "Decision test" }, { "description": "[freshness_clause](/records/pag/production-freshness-clause), [report_field](/records/pag/production-report-field)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-freshness", "title": "Freshness" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "Did the read set move beneath the verdict?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "the moved set is empty", "term": "Decision test" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [standing_line](/records/pag/production-standing-line)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-standing", "title": "Standing" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Where does this stage refuse to continue?", "term": "Question" }, { "description": "set", "term": "Answer shape" }, { "description": "a refusal condition is named before the irreversible write", "term": "Decision test" }, { "description": "injection-gate", "term": "Role" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [refusal_line](/records/pag/production-refusal-line)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-refusal", "title": "Refusal" }, { "blocks": [ { "items": [ "Axis: [verification](/records/reasoning/axis-verification)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Does the observation locate a failure, or is an absence of failures read as proof?", "term": "Question" }, { "description": "set", "term": "Answer shape" }, { "description": "every observed location is reported as located, and no observed absence is reported as verified", "term": "Decision test" }, { "description": "[report_field](/records/pag/production-report-field)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ver-observation", "title": "Located Observation" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Is every task done?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "every task is done", "term": "Decision test" }, { "description": "completion-marker", "term": "Role" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-completion", "title": "Completion" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Is nothing left to resolve?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "no open items remain", "term": "Decision test" }, { "description": "both", "term": "Role" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-saturation", "title": "Saturation" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)" ], "kind": "list" }, { "entries": [ { "description": "Has progress stopped increasing?", "term": "Question" }, { "description": "counter", "term": "Answer shape" }, { "description": "progress is unchanged across a bounded window", "term": "Decision test" }, { "description": "injection-gate", "term": "Role" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-diminishing-returns", "title": "Diminishing Returns" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "Is it blocked on external input?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [result_line](/records/pag/production-result-line), [wait_statement](/records/pag/production-wait-statement)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-block", "title": "Blocked Run" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [optimization](/records/reasoning/math-type-optimization)" ], "kind": "list" }, { "entries": [ { "description": "Do saturation, completion and verification all hold, or is the run blocked?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "saturation, completion and verification all hold, or ter-block holds", "term": "Decision test" }, { "description": "completion-marker", "term": "Role" }, { "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion), [report_field](/records/pag/production-report-field)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-stop", "title": "Stop Condition" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [set-theory](/records/reasoning/math-type-set-theory)" ], "kind": "list" }, { "entries": [ { "description": "Is the candidate promoted, or only produced?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "a clean verdict precedes the move into accepted state", "term": "Decision test" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-promotion", "title": "Promotion" }, { "blocks": [ { "items": [ "Axis: [termination](/records/reasoning/axis-termination)", "Math type: [logic](/records/reasoning/math-type-logic)" ], "kind": "list" }, { "entries": [ { "description": "Is the boundary to the external system explicit, and who crosses it?", "term": "Question" }, { "description": "boolean", "term": "Answer shape" }, { "description": "the publication gate names its party", "term": "Decision test" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports", "term": "Checked by" }, { "description": "Every structured document whose constructs ground the node", "term": "Population" }, { "description": "A verdict stands until the document, the grammar or the node changes", "term": "Freshness" }, { "description": "The validator fails a gate that omits the clause the node asks for", "term": "Refusal" }, { "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean", "term": "Evidence" }, { "description": "The gate clause the node asks for, which every document's gate conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-node-ter-publication", "title": "Publication" } ], "title": "The nodes" }, { "icon": "bi-signpost-split", "id": "the-mathematics", "intro": "The predicates are typed by these math types, each listed with its contracts and the domains of mathematics it draws on.", "subsections": [ { "blocks": [ { "entries": [ { "description": "What members exist?", "term": "Question" }, { "description": "[set-theory](/records/reasoning/math-domain-set-theory)", "term": "Fields" }, { "description": "membership · cardinality · emptiness", "term": "Predicate family" }, { "description": "set | boolean | ratio", "term": "Yields shape" }, { "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Smell Taxonomy](/records/algorithms/smell-taxonomy), [Responsibility Boundary](/records/algorithms/responsibility-boundary), [Canonical Data](/records/algorithms/canonical-data), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Canonical Semantics](/records/algorithms/canonical-semantics), [Self-Description and Discovery](/records/algorithms/self-description-and-discovery), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Capability Disclosure](/records/algorithms/capability-disclosure), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Explicit Termination](/records/algorithms/explicit-termination), [Context Initialization](/records/algorithms/context-initialization), [Early Success Exit](/records/algorithms/early-success-exit), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Coverage Workspace](/records/algorithms/coverage-workspace), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Custom Type Registration](/records/algorithms/custom-type-registration), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-set-theory", "title": "set-theory" }, { "blocks": [ { "entries": [ { "description": "Does it hold, and what follows from it?", "term": "Question" }, { "description": "[logic](/records/reasoning/math-domain-logic)", "term": "Fields" }, { "description": "boolean predicate", "term": "Predicate family" }, { "description": "boolean", "term": "Yields shape" }, { "description": "[Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Principle Extraction](/records/algorithms/principle-extraction), [Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Agent Generation Completion](/records/algorithms/agent-generation-completion), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Anti-Pattern Inversion](/records/algorithms/anti-pattern-inversion), [Architecture Smell Record](/records/algorithms/architecture-smell-record), [Document Truth Alignment](/records/algorithms/document-truth-alignment), [Interface Contract](/records/algorithms/interface-contract), [Substitutability](/records/algorithms/substitutability), [Extension Point](/records/algorithms/extension-point), [Behavioral Dispatch](/records/algorithms/behavioral-dispatch), [Port Adapter](/records/algorithms/port-adapter), [Transaction Boundary](/records/algorithms/transaction-boundary), [Idempotent Side Effect](/records/algorithms/idempotent-side-effect), [Deterministic Core](/records/algorithms/deterministic-core), [Error Boundary](/records/algorithms/error-boundary), [Cache Correctness](/records/algorithms/cache-correctness), [Security Policy](/records/algorithms/security-policy), [Control Plane](/records/algorithms/control-plane), [Universal Architectural Concern Template](/records/algorithms/universal-architectural-concern-template), [Consumer Config SSOT](/records/algorithms/consumer-config-ssot), [Architectural Force Classification](/records/algorithms/architectural-force-classification), [Conflict and Tension Resolution](/records/algorithms/conflict-and-tension-resolution), [Violation Detection](/records/algorithms/violation-detection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Modular Boundary Compliance](/records/algorithms/modular-boundary-compliance), [Contract Compatibility](/records/algorithms/contract-compatibility), [Runtime Extensibility](/records/algorithms/runtime-extensibility), [Event and Messaging Consistency](/records/algorithms/event-and-messaging-consistency), [State and Transaction Safety](/records/algorithms/state-and-transaction-safety), [Correctness Verification](/records/algorithms/correctness-verification), [Resilience Policy](/records/algorithms/resilience-policy), [Security Governance](/records/algorithms/security-governance), [Control Plane Coordination](/records/algorithms/control-plane-coordination), [Metaprogramming Safety](/records/algorithms/metaprogramming-safety), [Model Lifecycle Governance](/records/algorithms/model-lifecycle-governance), [Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Constraints Over Shortcuts](/records/algorithms/no-shortcuts), [Forward Compatibility Over Backward Compatibility](/records/algorithms/no-backward-compat), [Fail-Fast Over Fallback](/records/algorithms/no-fallback), [Explicit Removal Over Deprecation](/records/algorithms/no-deprecation), [Greenfield Over Legacy](/records/algorithms/no-legacy), [Single-Path Determinism Over Dual-Path](/records/algorithms/no-dual-path), [Immediacy Over Deferring](/records/algorithms/no-deferring), [Mandatory Over Optional](/records/algorithms/no-optional), [Now Over For-Now](/records/algorithms/no-for-now), [Observed Execution Over Unobserved](/records/algorithms/no-unobserved), [Compression Over Repetition](/records/algorithms/no-uncompressed), [Approved Evolution Over Unapproved](/records/algorithms/no-unapproved), [Enforced Feedback Over Ignored](/records/algorithms/no-ignored-feedback), [Single Owner Over Shared Ownership](/records/algorithms/no-shared-ownership), [Bounded Lifetime Over Unbounded](/records/algorithms/no-unbounded), [Enforced Symmetry Over Asymmetric Lifecycle](/records/algorithms/no-asymmetric), [Explicit Retention Over Implicit](/records/algorithms/no-implicit-retention), [Structural Release Over Discipline](/records/algorithms/no-discipline-release), [Immutable Data Over Mutable State](/records/algorithms/no-mutable), [Errors As Language Over Silent Errors](/records/algorithms/no-silent), [Explicit Invalidity Over Hidden](/records/algorithms/no-hidden-invalidity), [Event Emission Over Parent Callbacks](/records/algorithms/no-callbacks), [Monotonic Growth Over Retraction](/records/algorithms/no-retraction), [Semantic Addressing Over Location Addressing](/records/algorithms/no-location), [Ordinal Time Over Timestamps](/records/algorithms/no-timestamps), [Homoiconicity Over Separation](/records/algorithms/no-separation), [Bounded Complexity Over Unlimited](/records/algorithms/no-unlimited), [Computed Health Over Metric Health](/records/algorithms/no-metrics), [Secret Store Over Hardcoded Secrets](/records/algorithms/no-hardcoded-secrets), [Boundary Validation Over Unvalidated Input](/records/algorithms/no-unvalidated-input), [Least Privilege Over Broad Privilege](/records/algorithms/no-broad-privilege), [Config Externalization Over Env Fallback](/records/algorithms/no-env-fallback), [Profile-First Over Unmeasured Optimization](/records/algorithms/no-unmeasured-optimization), [Rule As Code Over Convention](/records/algorithms/no-convention-enforcement), [Design By Contract Over Implicit Contract](/records/algorithms/no-implicit-contract), [Versioned Evolution Over Breaking Change](/records/algorithms/no-breaking-change), [Schema-Validated Boundary Over Untyped](/records/algorithms/no-untyped-boundary), [Atomic Boundary Over Partial Commit](/records/algorithms/no-partial-commit), [Saga Compensation Over Distributed 2PC](/records/algorithms/no-distributed-2pc), [Async Events Over Synchronous Cross-Boundary](/records/algorithms/no-sync-cross-boundary), [Observable Signals Over Opaque Runtime](/records/algorithms/no-opaque-runtime), [Injected Dependency Over Hidden](/records/algorithms/no-hidden-dependency), [Convention Discovery Over Hardcoded Wiring](/records/algorithms/no-hardcoded-wiring), [Declarative Config Over Imperative](/records/algorithms/no-imperative-config), [Anti-Corruption Layer Over Cross-Context Leak](/records/algorithms/no-leaky-context), [Injected Nondeterminism Over Hidden](/records/algorithms/no-hidden-nondeterminism), [Pattern By Fit Over Speculative Pattern](/records/algorithms/no-speculative-pattern), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Automation Completion Status](/records/algorithms/automation-completion-status), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Verification Execution](/records/algorithms/verification-execution), [Violation Classification](/records/algorithms/violation-classification), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Invocation Join](/records/algorithms/invocation-join), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [Evidence Verdict](/records/algorithms/evidence-verdict), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Concern Classification](/records/algorithms/concern-classification), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Completion](/records/algorithms/taxonomy-completion), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder), [Alignment Cadence](/records/algorithms/alignment-cadence)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-logic", "title": "logic" }, { "blocks": [ { "entries": [ { "description": "What connects what?", "term": "Question" }, { "description": "[category-theory](/records/reasoning/math-domain-category-theory)", "term": "Fields" }, { "description": "reachability · coverage · degree", "term": "Predicate family" }, { "description": "edge-list", "term": "Yields shape" }, { "description": "[Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Anti-Pattern Relationship Record](/records/algorithms/anti-pattern-relationship-record), [Coupling Control](/records/algorithms/coupling-control), [Observability Trace](/records/algorithms/observability-trace), [Causality Ordering](/records/algorithms/causality-ordering), [Finite State Machine](/records/algorithms/finite-state-machine), [Statecharts](/records/algorithms/statecharts), [Petri Nets](/records/algorithms/petri-nets), [Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Architecture Knowledge Graph](/records/algorithms/architecture-knowledge-graph), [Dependency Closure](/records/algorithms/dependency-closure), [Reinforcement Propagation](/records/algorithms/reinforcement-propagation), [Observability and Auditability](/records/algorithms/observability-and-auditability), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Stage Ordering](/records/algorithms/stage-ordering), [Path Role Walk](/records/algorithms/path-role-walk)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-graph", "title": "graph" }, { "blocks": [ { "entries": [ { "description": "How are parts arranged under laws?", "term": "Question" }, { "description": "[algebra](/records/reasoning/math-domain-algebra)", "term": "Fields" }, { "description": "composition · ordering invariant", "term": "Predicate family" }, { "description": "ordered-structure", "term": "Yields shape" }, { "description": "[Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Anti-Pattern Remediation Algebra](/records/algorithms/anti-pattern-remediation-algebra), [Structural Mediation](/records/algorithms/structural-mediation), [Architecture Refactoring Roadmap](/records/algorithms/architecture-refactoring-roadmap), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Assembly Composition](/records/algorithms/assembly-composition), [Name Projection](/records/algorithms/name-projection), [Dialect Resolution](/records/algorithms/dialect-resolution)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-algebra", "title": "algebra" }, { "blocks": [ { "entries": [ { "description": "How do states vary?", "term": "Question" }, { "description": "[analysis](/records/reasoning/math-domain-analysis)", "term": "Fields" }, { "description": "operation applied to state", "term": "Predicate family" }, { "description": "operation", "term": "Yields shape" }, { "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Event Messaging](/records/algorithms/event-messaging), [Streaming Dataflow](/records/algorithms/streaming-dataflow), [Measurement Normalization](/records/algorithms/measurement-normalization), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Scalability Projection](/records/algorithms/scalability-projection), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-analysis", "title": "analysis" }, { "blocks": [ { "entries": [ { "description": "What is admissible or best?", "term": "Question" }, { "description": "validation · threshold · argmax", "term": "Predicate family" }, { "description": "boolean | ranking | number", "term": "Yields shape" }, { "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Replacement Safety](/records/algorithms/replacement-safety), [First-Time Initiation](/records/algorithms/first-time-initiation), [Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Verification Fitness](/records/algorithms/verification-fitness), [Performance Scaling](/records/algorithms/performance-scaling), [Architecture Selection Meta-Algorithm](/records/algorithms/architecture-selection-meta-algorithm), [Severity Policy](/records/algorithms/severity-policy), [Refactor Selection](/records/algorithms/refactor-selection), [Architecture Assessment](/records/algorithms/architecture-assessment), [Pattern Selection](/records/algorithms/pattern-selection), [Performance and Scalability](/records/algorithms/performance-and-scalability), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance), [Architectural Recommendation](/records/algorithms/architectural-recommendation), [Architecture Decision Support](/records/algorithms/architecture-decision-support), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity Assignment](/records/algorithms/severity-assignment), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [Validation Gate](/records/algorithms/validation-gate), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-optimization", "title": "optimization" }, { "blocks": [ { "entries": [ { "description": "What is preserved under change?", "term": "Question" }, { "description": "[topology](/records/reasoning/math-domain-topology)", "term": "Fields" }, { "description": "invariant / symmetry", "term": "Predicate family" }, { "description": "boolean", "term": "Yields shape" }, { "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Portability Environment](/records/algorithms/portability-environment), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Placement Isolation](/records/algorithms/placement-isolation)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-topology", "title": "topology" }, { "blocks": [ { "entries": [ { "description": "How certain or likely is it?", "term": "Question" }, { "description": "[probability](/records/reasoning/math-domain-probability)", "term": "Fields" }, { "description": "confidence · distribution · counter", "term": "Predicate family" }, { "description": "number[0,1]", "term": "Yields shape" }, { "description": "[Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary), [Queuing Theory](/records/algorithms/queuing-theory), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Research Guidance](/records/algorithms/research-guidance), [Validation Score](/records/algorithms/validation-score), [Tool Calibration](/records/algorithms/tool-calibration), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Compliance Gap](/records/algorithms/compliance-gap), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Distillation Metrics](/records/algorithms/distillation-metrics)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-probability", "title": "probability" }, { "blocks": [ { "entries": [ { "description": "What is novel, and how compressible is it?", "term": "Question" }, { "description": "[information-theory](/records/reasoning/math-domain-information-theory)", "term": "Fields" }, { "description": "novelty · dedup · hash", "term": "Predicate family" }, { "description": "hash | novelty-score | boolean", "term": "Yields shape" }, { "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Coverage Ledger](/records/algorithms/coverage-ledger), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-information-theory", "title": "information-theory" }, { "blocks": [ { "entries": [ { "description": "What procedure produces it?", "term": "Question" }, { "description": "[computation](/records/reasoning/math-domain-computation)", "term": "Fields" }, { "description": "algorithm / loop", "term": "Predicate family" }, { "description": "procedure", "term": "Yields shape" }, { "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Creator Kernel](/records/algorithms/agent-creator-kernel), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel), [Anti-Pattern Rule Compiler](/records/algorithms/anti-pattern-rule-compiler), [Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Construction Boundary](/records/algorithms/construction-boundary), [Saga Compensation](/records/algorithms/saga-compensation), [Declarative Metaprogramming](/records/algorithms/declarative-metaprogramming), [Manifest-Driven Documentation](/records/algorithms/manifest-driven-documentation), [Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation), [Architecture Catalog Compiler](/records/algorithms/architecture-catalog-compiler), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Automation Kernel](/records/algorithms/automation-kernel), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Centralization Kernel](/records/algorithms/centralization-kernel), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Compilation Stage](/records/algorithms/compilation-stage), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Checklist Creation Kernel](/records/algorithms/checklist-creation-kernel), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [Codebase Verification Kernel](/records/algorithms/codebase-verification-kernel), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Contract-Based Verification Kernel](/records/algorithms/contract-based-verification-kernel), [Convergence Walk](/records/algorithms/convergence-walk), [Test Authoring](/records/algorithms/test-authoring), [Test Coverage Kernel](/records/algorithms/test-coverage-kernel), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Living Profile Kernel](/records/algorithms/living-profile-kernel), [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [Quality Governance Loop](/records/algorithms/quality-governance-loop), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Governed Construction Boundary](/records/algorithms/governed-construction-boundary), [Type-Migration Centralization](/records/algorithms/type-migration-centralization), [Container Reshape](/records/algorithms/container-reshape), [Taxonomy Kernel](/records/algorithms/taxonomy-kernel)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-computation", "title": "computation" }, { "blocks": [ { "entries": [ { "description": "What stable pattern arises, and has it converged?", "term": "Question" }, { "description": "fixed-point · convergence · oscillation", "term": "Predicate family" }, { "description": "boolean | counter", "term": "Yields shape" }, { "description": "[Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Anti-Pattern Propagation Kernel](/records/algorithms/anti-pattern-propagation-kernel), [Resilience Control](/records/algorithms/resilience-control), [Recovery Deployment](/records/algorithms/recovery-deployment), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Verification Loop](/records/algorithms/verification-loop), [Iteration Bound](/records/algorithms/iteration-bound), [Recursion Control](/records/algorithms/recursion-control)", "term": "Contracts" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type", "term": "Checked by" }, { "description": "Every algorithm record, node, axis and substrate node that names the math type", "term": "Population" }, { "description": "A verdict stands until the math type's shapes or a record that names it changes", "term": "Freshness" }, { "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist", "term": "Refusal" }, { "description": "None, because a math type is a family of answers, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean", "term": "Evidence" }, { "description": "The math type's shapes, which every yield and answer shape conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-type-dynamical-systems", "title": "dynamical-systems" }, { "blocks": [ { "entries": [ { "description": "quantity", "term": "Studies" }, { "description": "What can be counted or measured?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-number", "title": "number" }, { "blocks": [ { "entries": [ { "description": "operations and structures", "term": "Studies" }, { "description": "What rules govern transformations?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-algebra", "title": "algebra" }, { "blocks": [ { "entries": [ { "description": "space and form", "term": "Studies" }, { "description": "What shapes and spaces exist?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-geometry", "title": "geometry" }, { "blocks": [ { "entries": [ { "description": "continuity and connectivity", "term": "Studies" }, { "description": "What remains invariant under deformation?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-topology", "title": "topology" }, { "blocks": [ { "entries": [ { "description": "change and limits", "term": "Studies" }, { "description": "How do quantities vary?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-analysis", "title": "analysis" }, { "blocks": [ { "entries": [ { "description": "truth and inference", "term": "Studies" }, { "description": "What statements follow from others?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-logic", "title": "logic" }, { "blocks": [ { "entries": [ { "description": "collection and membership", "term": "Studies" }, { "description": "What objects can be constructed?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-set-theory", "title": "set-theory" }, { "blocks": [ { "entries": [ { "description": "discrete arrangements", "term": "Studies" }, { "description": "How many configurations exist?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-combinatorics", "title": "combinatorics" }, { "blocks": [ { "entries": [ { "description": "uncertainty", "term": "Studies" }, { "description": "What outcomes are possible and likely?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-probability", "title": "probability" }, { "blocks": [ { "entries": [ { "description": "information and compression", "term": "Studies" }, { "description": "What patterns can be encoded?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-information-theory", "title": "information-theory" }, { "blocks": [ { "entries": [ { "description": "procedures and algorithms", "term": "Studies" }, { "description": "What can be generated or solved?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-computation", "title": "computation" }, { "blocks": [ { "entries": [ { "description": "relationships between structures", "term": "Studies" }, { "description": "How do mathematical worlds connect?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the math types and foundations that name the domain", "term": "Checked by" }, { "description": "Every math type and foundation layer that names the domain", "term": "Population" }, { "description": "A verdict stands until the domain list or a record that names a domain changes", "term": "Freshness" }, { "description": "The gate fails on a reference to a domain that does not exist", "term": "Refusal" }, { "description": "None, because a math domain is a field of study, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve", "term": "Evidence" }, { "description": "The domain list, which every math type and foundation that names a domain cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-math-domain-category-theory", "title": "category-theory" } ], "title": "The mathematics" }, { "icon": "bi-signpost-split", "id": "the-dimensions", "intro": "The ontological dimensions are what can be observed about a subject, and each is listed with the test surfaces that observe it.", "subsections": [ { "blocks": [ { "items": [ "Nature: object" ], "kind": "list" }, { "entries": [ { "description": "What exists?", "term": "Question" }, { "description": "[data-correctness](/records/reasoning/test-surface-data-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-identity", "title": "identity" }, { "blocks": [ { "items": [ "Nature: elements" ], "kind": "list" }, { "entries": [ { "description": "What is it made of?", "term": "Question" }, { "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-composition", "title": "composition" }, { "blocks": [ { "items": [ "Nature: arrangement" ], "kind": "list" }, { "entries": [ { "description": "How are parts arranged?", "term": "Question" }, { "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-structure", "title": "structure" }, { "blocks": [ { "items": [ "Nature: mapping" ], "kind": "list" }, { "entries": [ { "description": "What connects it to other things?", "term": "Question" }, { "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-relation", "title": "relation" }, { "blocks": [ { "items": [ "Nature: position" ], "kind": "list" }, { "entries": [ { "description": "Where is it?", "term": "Question" }, { "description": "[geometry](/records/reasoning/math-domain-geometry)", "term": "Fields" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-space", "title": "space" }, { "blocks": [ { "items": [ "Nature: process" ], "kind": "list" }, { "entries": [ { "description": "When does it occur?", "term": "Question" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-time", "title": "time" }, { "blocks": [ { "items": [ "Nature: condition" ], "kind": "list" }, { "entries": [ { "description": "What condition is it in?", "term": "Question" }, { "description": "[state-correctness](/records/reasoning/test-surface-state-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-state", "title": "state" }, { "blocks": [ { "items": [ "Nature: operation" ], "kind": "list" }, { "entries": [ { "description": "How does it transform?", "term": "Question" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-change", "title": "change" }, { "blocks": [ { "items": [ "Nature: dynamics" ], "kind": "list" }, { "entries": [ { "description": "What does it do?", "term": "Question" }, { "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-behavior", "title": "behavior" }, { "blocks": [ { "items": [ "Nature: mapping" ], "kind": "list" }, { "entries": [ { "description": "What role does it fulfill?", "term": "Question" }, { "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-function", "title": "function" }, { "blocks": [ { "items": [ "Nature: mechanism" ], "kind": "list" }, { "entries": [ { "description": "Why does it happen?", "term": "Question" }, { "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-cause", "title": "cause" }, { "blocks": [ { "items": [ "Nature: semantics" ], "kind": "list" }, { "entries": [ { "description": "What does it signify?", "term": "Question" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-meaning", "title": "meaning" }, { "blocks": [ { "items": [ "Nature: hierarchy" ], "kind": "list" }, { "entries": [ { "description": "At what level does it exist?", "term": "Question" }, { "description": "[performance-correctness](/records/reasoning/test-surface-performance-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-scale", "title": "scale" }, { "blocks": [ { "items": [ "Nature: distribution" ], "kind": "list" }, { "entries": [ { "description": "How certain is it?", "term": "Question" }, { "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-probability", "title": "probability" }, { "blocks": [ { "items": [ "Nature: creation" ], "kind": "list" }, { "entries": [ { "description": "What deviates from expectation?", "term": "Question" }, { "description": "[determinism-correctness](/records/reasoning/test-surface-determinism-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension", "term": "Checked by" }, { "description": "Every test surface and ontology node that names the dimension", "term": "Population" }, { "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change", "term": "Freshness" }, { "description": "The gate fails on a surface or node that names a dimension that does not exist", "term": "Refusal" }, { "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The dimension list, which every surface and node that names a dimension cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-dimension-novelty", "title": "novelty" } ], "title": "The dimensions" }, { "icon": "bi-signpost-split", "id": "the-lenses", "intro": "The analysis lenses are how a subject is seen. Each sits on one universal axis and is listed with the fields of mathematics it draws on, the surfaces and detectors it feeds and the test surfaces that see through it.", "subsections": [ { "blocks": [ { "items": [ "Nature: arrangement", "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)" ], "kind": "list" }, { "entries": [ { "description": "How are the parts organized?", "term": "Question" }, { "description": "[algebra](/records/reasoning/math-domain-algebra), [category-theory](/records/reasoning/math-domain-category-theory)", "term": "Fields" }, { "description": "structural_duplication, copy_paste_duplication", "term": "Surfaces" }, { "description": "[Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection)", "term": "Detectors" }, { "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-structure", "title": "structure" }, { "blocks": [ { "items": [ "Nature: time", "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)" ], "kind": "list" }, { "entries": [ { "description": "How does it vary through time?", "term": "Question" }, { "description": "differential-equations, dynamical-systems", "term": "Fields" }, { "description": "temporal_coupling", "term": "Surfaces" }, { "description": "[Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection)", "term": "Detectors" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-time", "title": "time" }, { "blocks": [ { "items": [ "Nature: location", "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)" ], "kind": "list" }, { "entries": [ { "description": "How is it distributed in space?", "term": "Question" }, { "description": "[geometry](/records/reasoning/math-domain-geometry), [topology](/records/reasoning/math-domain-topology)", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-space", "title": "space" }, { "blocks": [ { "items": [ "Nature: distribution", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What regularities emerge from many observations?", "term": "Question" }, { "description": "[probability](/records/reasoning/math-domain-probability), statistics", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" }, { "description": "[performance-correctness](/records/reasoning/test-surface-performance-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-statistical", "title": "statistical" }, { "blocks": [ { "items": [ "Nature: recurrence", "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)" ], "kind": "list" }, { "entries": [ { "description": "What repeats, and how often?", "term": "Question" }, { "description": "harmonic-analysis", "term": "Fields" }, { "description": "copy_paste_duplication", "term": "Surfaces" }, { "description": "[Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection)", "term": "Detectors" }, { "description": "[observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-frequency", "title": "frequency" }, { "blocks": [ { "items": [ "Nature: order", "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)" ], "kind": "list" }, { "entries": [ { "description": "In what order do things occur?", "term": "Question" }, { "description": "[logic](/records/reasoning/math-domain-logic), [combinatorics](/records/reasoning/math-domain-combinatorics)", "term": "Fields" }, { "description": "sequential_duplication", "term": "Surfaces" }, { "description": "[Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication)", "term": "Detectors" }, { "description": "[state-correctness](/records/reasoning/test-surface-state-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-sequential", "title": "sequential" }, { "blocks": [ { "items": [ "Nature: relationships", "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)" ], "kind": "list" }, { "entries": [ { "description": "What connects what?", "term": "Question" }, { "description": "[algebra](/records/reasoning/math-domain-algebra), [category-theory](/records/reasoning/math-domain-category-theory)", "term": "Fields" }, { "description": "relational_duplication", "term": "Surfaces" }, { "description": "[Relational Graph Duplication](/records/algorithms/relational-graph-duplication)", "term": "Detectors" }, { "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-relation", "title": "relation" }, { "blocks": [ { "items": [ "Nature: action", "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)" ], "kind": "list" }, { "entries": [ { "description": "How does an entity tend to act?", "term": "Question" }, { "description": "dynamical-systems", "term": "Fields" }, { "description": "behavioral_inconsistency", "term": "Surfaces" }, { "description": "[Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)", "term": "Detectors" }, { "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-behavior", "title": "behavior" }, { "blocks": [ { "items": [ "Nature: purpose", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What role does something perform?", "term": "Question" }, { "description": "functional-analysis", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-function", "title": "function" }, { "blocks": [ { "items": [ "Nature: meaning", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What meaning is conveyed?", "term": "Question" }, { "description": "none", "term": "Fields" }, { "description": "conceptual_duplication", "term": "Surfaces" }, { "description": "[Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection)", "term": "Detectors" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-meaning", "title": "meaning" }, { "blocks": [ { "items": [ "Nature: cause", "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)" ], "kind": "list" }, { "entries": [ { "description": "What produces what?", "term": "Question" }, { "description": "mathematical-modeling", "term": "Fields" }, { "description": "causal_duplication", "term": "Surfaces" }, { "description": "[Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication)", "term": "Detectors" }, { "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-cause", "title": "cause" }, { "blocks": [ { "items": [ "Nature: expectation", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What usually follows?", "term": "Question" }, { "description": "applied-mathematics", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-prediction", "title": "prediction" }, { "blocks": [ { "items": [ "Nature: exception", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What breaks the normal pattern?", "term": "Question" }, { "description": "statistics", "term": "Fields" }, { "description": "behavioral_inconsistency", "term": "Surfaces" }, { "description": "[Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection)", "term": "Detectors" }, { "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-anomaly", "title": "anomaly" }, { "blocks": [ { "items": [ "Nature: development", "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)" ], "kind": "list" }, { "entries": [ { "description": "How does the pattern itself change?", "term": "Question" }, { "description": "dynamical-systems", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" }, { "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)", "term": "Test surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-change", "title": "change" }, { "blocks": [ { "items": [ "Nature: self-similarity", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "Does the same structure recur at different scales?", "term": "Question" }, { "description": "fractal-geometry, renormalization", "term": "Fields" }, { "description": "scale_duplication", "term": "Surfaces" }, { "description": "[Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication)", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-fractal", "title": "fractal" }, { "blocks": [ { "items": [ "Nature: transformation", "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)" ], "kind": "list" }, { "entries": [ { "description": "How does one state become another?", "term": "Question" }, { "description": "[algebra](/records/reasoning/math-domain-algebra), [computation](/records/reasoning/math-domain-computation)", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-transformation", "title": "transformation" }, { "blocks": [ { "items": [ "Nature: invariance", "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)" ], "kind": "list" }, { "entries": [ { "description": "What remains unchanged?", "term": "Question" }, { "description": "[topology](/records/reasoning/math-domain-topology), symmetry", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-invariant", "title": "invariant" }, { "blocks": [ { "items": [ "Nature: selection", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "What is the best possible state?", "term": "Question" }, { "description": "operations-research", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-optimization", "title": "optimization" }, { "blocks": [ { "items": [ "Nature: difficulty", "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)" ], "kind": "list" }, { "entries": [ { "description": "How difficult is the transformation?", "term": "Question" }, { "description": "computation-theory", "term": "Fields" }, { "description": "none", "term": "Surfaces" }, { "description": "none", "term": "Detectors" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension", "term": "Checked by" }, { "description": "The code the lens's detectors scan, and every surface that names the lens", "term": "Population" }, { "description": "A verdict stands until the scanned code, a detector or a surface changes", "term": "Freshness" }, { "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens", "term": "Refusal" }, { "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean", "term": "Evidence" }, { "description": "The lens list and the algorithm records, which a surface and a detector cite", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-lens-complexity", "title": "complexity" } ], "title": "The lenses" }, { "icon": "bi-signpost-split", "id": "the-modes", "intro": "Each reasoning mode is listed with the practice it names and the techniques that work in it.", "subsections": [ { "blocks": [ { "entries": [ { "description": "identifying patterns or examples", "term": "Mode" }, { "description": "What is there?", "term": "Question" }, { "description": "[static-analysis](/records/reasoning/technique-static-analysis), [runtime-validation](/records/reasoning/technique-runtime-validation), [profiling](/records/reasoning/technique-profiling), [heap-analysis](/records/reasoning/technique-heap-analysis), [monitoring](/records/reasoning/technique-monitoring)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-observation", "title": "observation" }, { "blocks": [ { "entries": [ { "description": "defining objects", "term": "Mode" }, { "description": "How can it be characterized?", "term": "Question" }, { "description": "[tracing](/records/reasoning/technique-tracing)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-description", "title": "description" }, { "blocks": [ { "entries": [ { "description": "finding similarities and differences", "term": "Mode" }, { "description": "How is it similar or different?", "term": "Question" }, { "description": "[unit-testing](/records/reasoning/technique-unit-testing), [integration-testing](/records/reasoning/technique-integration-testing), [end-to-end-testing](/records/reasoning/technique-end-to-end-testing), [differential-testing](/records/reasoning/technique-differential-testing), [contract-testing](/records/reasoning/technique-contract-testing), [assertion-checking](/records/reasoning/technique-assertion-checking), [read-after-write-verification](/records/reasoning/technique-read-after-write-verification)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-comparison", "title": "comparison" }, { "blocks": [ { "entries": [ { "description": "grouping by properties", "term": "Mode" }, { "description": "Which kind is it?", "term": "Question" }, { "description": "[property-based-testing](/records/reasoning/technique-property-based-testing)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-classification", "title": "classification" }, { "blocks": [ { "entries": [ { "description": "removing irrelevant details", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-abstraction", "title": "abstraction" }, { "blocks": [ { "entries": [ { "description": "extending examples into principles", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-generalization", "title": "generalization" }, { "blocks": [ { "entries": [ { "description": "expressing ideas symbolically", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-formalization", "title": "formalization" }, { "blocks": [ { "entries": [ { "description": "identifying mechanisms", "term": "Mode" }, { "description": "Why is it this way?", "term": "Question" }, { "description": "[model-checking](/records/reasoning/technique-model-checking)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-explanation", "title": "explanation" }, { "blocks": [ { "entries": [ { "description": "deriving necessary consequences", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-deduction", "title": "deduction" }, { "blocks": [ { "entries": [ { "description": "building objects that satisfy rules", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-construction", "title": "construction" }, { "blocks": [ { "entries": [ { "description": "establishing certainty", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-proof", "title": "proof" }, { "blocks": [ { "entries": [ { "description": "inferring future states", "term": "Mode" }, { "description": "What comes next?", "term": "Question" }, { "description": "[load-testing](/records/reasoning/technique-load-testing), [stress-testing](/records/reasoning/technique-stress-testing)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-prediction", "title": "prediction" }, { "blocks": [ { "entries": [ { "description": "selecting preferred solutions", "term": "Mode" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-optimization", "title": "optimization" }, { "blocks": [ { "entries": [ { "description": "modifying systems", "term": "Mode" }, { "description": "How can it be changed?", "term": "Question" }, { "description": "[fault-injection](/records/reasoning/technique-fault-injection), [chaos-testing](/records/reasoning/technique-chaos-testing), [mutation-testing](/records/reasoning/technique-mutation-testing)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-intervention", "title": "intervention" }, { "blocks": [ { "entries": [ { "description": "generating new structures", "term": "Mode" }, { "description": "Can new examples be produced?", "term": "Question" }, { "description": "[fuzz-testing](/records/reasoning/technique-fuzz-testing)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-creation", "title": "creation" }, { "blocks": [ { "entries": [ { "description": "discovering the principles behind the examples", "term": "Mode" }, { "description": "What general principles emerge?", "term": "Question" }, { "description": "[deterministic-replay](/records/reasoning/technique-deterministic-replay)", "term": "Techniques" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes", "term": "Checked by" }, { "description": "Every technique, node, model step and document construct that names the mode", "term": "Population" }, { "description": "A verdict stands until the mode list or a record that names a mode changes", "term": "Freshness" }, { "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist", "term": "Refusal" }, { "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean", "term": "Evidence" }, { "description": "The mode list, which every technique, node, step and construct that names a mode cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-mode-reflection", "title": "reflection" } ], "title": "The modes" }, { "icon": "bi-signpost-split", "id": "the-representations", "intro": "A result can be encoded in any of these representation layers.", "subsections": [ { "blocks": [ { "kind": "text", "text": "equations, formulas, notation" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-symbolic", "title": "symbolic" }, { "blocks": [ { "kind": "text", "text": "statements, predicates, proofs" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-logic", "title": "logical" }, { "blocks": [ { "kind": "text", "text": "numbers, quantities, measurements" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-number", "title": "numerical" }, { "blocks": [ { "kind": "text", "text": "operations, groups, fields" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-algebra", "title": "algebraic" }, { "blocks": [ { "kind": "text", "text": "shapes, coordinates, spaces" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-geometry", "title": "geometric" }, { "blocks": [ { "kind": "text", "text": "connectivity, continuity" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-topology", "title": "topological" }, { "blocks": [ { "kind": "text", "text": "diagrams, graphs, networks" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-graph", "title": "graphical" }, { "blocks": [ { "kind": "text", "text": "linear transformations" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-matrix", "title": "matrix" }, { "blocks": [ { "kind": "text", "text": "mappings between spaces" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-function", "title": "functional" }, { "blocks": [ { "kind": "text", "text": "entropy, encoding, compression" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-information-theory", "title": "information-theoretic" }, { "blocks": [ { "kind": "text", "text": "distributions and likelihoods" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-probability", "title": "probabilistic" }, { "blocks": [ { "kind": "text", "text": "state transitions" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-dynamical-systems", "title": "dynamical" }, { "blocks": [ { "kind": "text", "text": "algorithms and programs" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-computation", "title": "computational" }, { "blocks": [ { "kind": "text", "text": "objects and morphisms" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation", "term": "Checked by" }, { "description": "Every node and document construct that names the representation", "term": "Population" }, { "description": "A verdict stands until the representations or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a node or construct that names a representation that does not exist", "term": "Refusal" }, { "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve", "term": "Evidence" }, { "description": "The representation list, which every node and construct that names a representation cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-representation-category-theory", "title": "categorical" } ], "title": "The representations" }, { "icon": "bi-signpost-split", "id": "the-pattern-types", "intro": "Each pattern type is listed with the mathematical viewpoint it takes.", "subsections": [ { "blocks": [ { "kind": "text", "text": "formal systems and equations" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-symbolic", "title": "symbolic" }, { "blocks": [ { "kind": "text", "text": "quantity and arithmetic" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-number", "title": "numerical" }, { "blocks": [ { "kind": "text", "text": "operations and transformations" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-algebra", "title": "algebraic" }, { "blocks": [ { "kind": "text", "text": "shape and space" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-geometry", "title": "geometric" }, { "blocks": [ { "kind": "text", "text": "connectivity and invariance" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-topology", "title": "topological" }, { "blocks": [ { "kind": "text", "text": "truth and implication" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-logic", "title": "logical" }, { "blocks": [ { "kind": "text", "text": "possible arrangements" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-combinatorics", "title": "combinatorial" }, { "blocks": [ { "kind": "text", "text": "distribution and variation" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-statistical", "title": "statistical" }, { "blocks": [ { "kind": "text", "text": "randomness and uncertainty" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-probability", "title": "probabilistic" }, { "blocks": [ { "kind": "text", "text": "compression and complexity" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-information", "title": "information" }, { "blocks": [ { "kind": "text", "text": "change over time" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-dynamical-systems", "title": "dynamical" }, { "blocks": [ { "kind": "text", "text": "procedures and algorithms" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-computation", "title": "computational" }, { "blocks": [ { "kind": "text", "text": "relationships between structures" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-category-theory", "title": "categorical" }, { "blocks": [ { "kind": "text", "text": "recursive self-similarity" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate over every ground that names the pattern type", "term": "Checked by" }, { "description": "Every construct and record that grounds the pattern type", "term": "Population" }, { "description": "A verdict stands until the pattern types or a record that names one changes", "term": "Freshness" }, { "description": "The gate fails on a ground that names a pattern type that does not exist", "term": "Refusal" }, { "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one", "term": "Evidence" }, { "description": "The pattern type list, which every ground that names a type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-pattern-type-fractal", "title": "fractal" } ], "title": "The pattern types" }, { "icon": "bi-signpost-split", "id": "the-models", "intro": "The models are sequences that restate the same cycle from different starting points.", "subsections": [ { "blocks": [ { "items": [ "Question: How does a pattern come to be?", "Recursion: emergence → difference" ], "kind": "list" }, { "entries": [ { "description": "[existence](/records/reasoning/substrate-node-existence) → [difference](/records/reasoning/substrate-node-difference) → [relation](/records/reasoning/substrate-node-relation) → [structure](/records/reasoning/substrate-node-structure) → [transformation](/records/reasoning/substrate-node-transformation) → [constraint](/records/reasoning/substrate-node-constraint) → [emergence](/records/reasoning/substrate-node-emergence)", "term": "Sequence" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model", "term": "Checked by" }, { "description": "Every model, its steps, and every document type that names it", "term": "Population" }, { "description": "A verdict stands until the model, its step kind or a document type that names it changes", "term": "Freshness" }, { "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve", "term": "Refusal" }, { "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean", "term": "Evidence" }, { "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-model-ontogenesis", "title": "ontogenesis" }, { "blocks": [ { "items": [ "Question: How is a pattern known?" ], "kind": "list" }, { "entries": [ { "description": "[observation](/records/reasoning/mode-observation) → [description](/records/reasoning/mode-description) → [comparison](/records/reasoning/mode-comparison) → [classification](/records/reasoning/mode-classification) → [explanation](/records/reasoning/mode-explanation) → [prediction](/records/reasoning/mode-prediction) → [intervention](/records/reasoning/mode-intervention) → [creation](/records/reasoning/mode-creation) → [reflection](/records/reasoning/mode-reflection)", "term": "Sequence" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model", "term": "Checked by" }, { "description": "Every model, its steps, and every document type that names it", "term": "Population" }, { "description": "A verdict stands until the model, its step kind or a document type that names it changes", "term": "Freshness" }, { "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve", "term": "Refusal" }, { "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean", "term": "Evidence" }, { "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-model-epistemology", "title": "epistemology" }, { "blocks": [ { "items": [ "Question: How does a system perceive, act, and adapt?", "Recursion: evolution → difference" ], "kind": "list" }, { "entries": [ { "description": "existence → difference → relation → structure → transformation → constraint → emergence → representation → memory → prediction → action → feedback → evolution", "term": "Sequence" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model", "term": "Checked by" }, { "description": "Every model, its steps, and every document type that names it", "term": "Population" }, { "description": "A verdict stands until the model, its step kind or a document type that names it changes", "term": "Freshness" }, { "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve", "term": "Refusal" }, { "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean", "term": "Evidence" }, { "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-model-cognition", "title": "cognition" }, { "blocks": [ { "items": [ "Question: How does pattern-work proceed?", "Recursion: create → exist" ], "kind": "list" }, { "entries": [ { "description": "exist → differentiate → relate → organize → transform → constrain → stabilize → represent → reasoning → predict → create", "term": "Sequence" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model", "term": "Checked by" }, { "description": "Every model, its steps, and every document type that names it", "term": "Population" }, { "description": "A verdict stands until the model, its step kind or a document type that names it changes", "term": "Freshness" }, { "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve", "term": "Refusal" }, { "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean", "term": "Evidence" }, { "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-model-pattern-cycle", "title": "pattern-cycle" } ], "title": "The models" }, { "icon": "bi-signpost-split", "id": "the-universal-axes", "intro": "The five universal axes are listed with the dimensions each one subsumes and the lenses that sit on it.", "subsections": [ { "blocks": [ { "entries": [ { "description": "What entities are present?", "term": "Question" }, { "description": "[identity](/records/reasoning/dimension-identity)", "term": "Subsumes" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists", "term": "Checked by" }, { "description": "Every lens that names the universal axis", "term": "Population" }, { "description": "A verdict stands until the universal axes or a lens changes", "term": "Freshness" }, { "description": "The gate fails on a lens that names a universal axis that does not exist", "term": "Refusal" }, { "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean", "term": "Evidence" }, { "description": "The universal axis list, which every lens cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-universal-axis-existence", "title": "existence" }, { "blocks": [ { "entries": [ { "description": "How are they organized?", "term": "Question" }, { "description": "[structure](/records/reasoning/dimension-structure), [space](/records/reasoning/dimension-space)", "term": "Subsumes" }, { "description": "[structural](/records/reasoning/lens-structure), [spatial](/records/reasoning/lens-space), [invariant](/records/reasoning/lens-invariant)", "term": "Lenses" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists", "term": "Checked by" }, { "description": "Every lens that names the universal axis", "term": "Population" }, { "description": "A verdict stands until the universal axes or a lens changes", "term": "Freshness" }, { "description": "The gate fails on a lens that names a universal axis that does not exist", "term": "Refusal" }, { "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean", "term": "Evidence" }, { "description": "The universal axis list, which every lens cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-universal-axis-arrangement", "title": "arrangement" }, { "blocks": [ { "entries": [ { "description": "How do they change?", "term": "Question" }, { "description": "[time](/records/reasoning/dimension-time), [change](/records/reasoning/dimension-change)", "term": "Subsumes" }, { "description": "[temporal](/records/reasoning/lens-time), [frequency](/records/reasoning/lens-frequency), [sequential](/records/reasoning/lens-sequential), [evolutionary](/records/reasoning/lens-change), [transformational](/records/reasoning/lens-transformation)", "term": "Lenses" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists", "term": "Checked by" }, { "description": "Every lens that names the universal axis", "term": "Population" }, { "description": "A verdict stands until the universal axes or a lens changes", "term": "Freshness" }, { "description": "The gate fails on a lens that names a universal axis that does not exist", "term": "Refusal" }, { "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean", "term": "Evidence" }, { "description": "The universal axis list, which every lens cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-universal-axis-dynamics", "title": "dynamics" }, { "blocks": [ { "entries": [ { "description": "How do they influence one another?", "term": "Question" }, { "description": "[relation](/records/reasoning/dimension-relation), [behavior](/records/reasoning/dimension-behavior), [cause](/records/reasoning/dimension-cause)", "term": "Subsumes" }, { "description": "[relational](/records/reasoning/lens-relation), [behavioral](/records/reasoning/lens-behavior), [causal](/records/reasoning/lens-cause)", "term": "Lenses" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists", "term": "Checked by" }, { "description": "Every lens that names the universal axis", "term": "Population" }, { "description": "A verdict stands until the universal axes or a lens changes", "term": "Freshness" }, { "description": "The gate fails on a lens that names a universal axis that does not exist", "term": "Refusal" }, { "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean", "term": "Evidence" }, { "description": "The universal axis list, which every lens cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-universal-axis-interaction", "title": "interaction" }, { "blocks": [ { "entries": [ { "description": "What meaning or principle can be inferred?", "term": "Question" }, { "description": "[meaning](/records/reasoning/dimension-meaning), [function](/records/reasoning/dimension-function), [probability](/records/reasoning/dimension-probability)", "term": "Subsumes" }, { "description": "[statistical](/records/reasoning/lens-statistical), [functional](/records/reasoning/lens-function), [semantic](/records/reasoning/lens-meaning), [predictive](/records/reasoning/lens-prediction), [anomaly](/records/reasoning/lens-anomaly), [fractal](/records/reasoning/lens-fractal), [optimization](/records/reasoning/lens-optimization), [complexity](/records/reasoning/lens-complexity)", "term": "Lenses" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists", "term": "Checked by" }, { "description": "Every lens that names the universal axis", "term": "Population" }, { "description": "A verdict stands until the universal axes or a lens changes", "term": "Freshness" }, { "description": "The gate fails on a lens that names a universal axis that does not exist", "term": "Refusal" }, { "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean", "term": "Evidence" }, { "description": "The universal axis list, which every lens cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-universal-axis-abstraction", "title": "abstraction" } ], "title": "The universal axes" }, { "icon": "bi-signpost-split", "id": "the-test-surfaces", "intro": "The test surfaces are what a system can be wrong about. Each is a dimension seen through a lens, listed with the invariant that must hold, the techniques that observe it, the predicate and what grounds it, the evidence it requires and the verdicts it can return. The architecture page reads the same grid in [what can drift, seen through how it drifts](/software-architecture/coverage#what-can-drift-seen-through-how-it-drifts).", "subsections": [ { "blocks": [ { "items": [ "Dimension: [meaning](/records/reasoning/dimension-meaning)", "Lens: [semantic](/records/reasoning/lens-meaning)", "Invariant: [correct-outputs](/records/reasoning/invariant-correct-outputs)", "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)" ], "kind": "list" }, { "entries": [ { "description": "An output is correct when it signifies what the input asked for, so the surface compares the meaning of the result with the meaning expected.", "term": "Fit" }, { "description": "wrong value, incorrect algorithm, wrong computation", "term": "Failure modes" }, { "description": "[unit-testing](/records/reasoning/technique-unit-testing), [property-based-testing](/records/reasoning/technique-property-based-testing), [differential-testing](/records/reasoning/technique-differential-testing), [assertion-checking](/records/reasoning/technique-assertion-checking)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "output(input) = expected(input)", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-semantic-correctness", "title": "semantic-correctness" }, { "blocks": [ { "items": [ "Dimension: [function](/records/reasoning/dimension-function)", "Lens: [behavioral](/records/reasoning/lens-behavior)", "Invariant: [correct-state-evolution](/records/reasoning/invariant-correct-state-evolution)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "A workflow fulfils its role through the actions it takes, so the surface reads the role from the transitions the system actually performs.", "term": "Fit" }, { "description": "invalid workflow, missing transition, incorrect business rule", "term": "Failure modes" }, { "description": "[integration-testing](/records/reasoning/technique-integration-testing), [model-checking](/records/reasoning/technique-model-checking)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "transition in allowedTransitions", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-functional-correctness", "title": "functional-correctness" }, { "blocks": [ { "items": [ "Dimension: [state](/records/reasoning/dimension-state)", "Lens: [sequential](/records/reasoning/lens-sequential)", "Invariant: [valid-state-transitions](/records/reasoning/invariant-valid-state-transitions)", "Predicate: [temporal-order](/records/vocabulary/predicate-type-temporal-order)" ], "kind": "list" }, { "entries": [ { "description": "A state is valid only relative to the one before it, so the surface checks conditions in the order they occur.", "term": "Fit" }, { "description": "invalid state, broken state transitions, violated lifecycle rules", "term": "Failure modes" }, { "description": "[assertion-checking](/records/reasoning/technique-assertion-checking), [property-based-testing](/records/reasoning/technique-property-based-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "state[t+1] in next(state[t])", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-state-correctness", "title": "state-correctness" }, { "blocks": [ { "items": [ "Dimension: [structure](/records/reasoning/dimension-structure)", "Lens: [structural](/records/reasoning/lens-structure)", "Invariant: [valid-interfaces-and-contracts](/records/reasoning/invariant-valid-interfaces-and-contracts)", "Predicate: [schema](/records/vocabulary/predicate-type-schema)" ], "kind": "list" }, { "entries": [ { "description": "A contract is an arrangement of fields and types, so the surface compares the shape of a payload with the shape the contract declares.", "term": "Fit" }, { "description": "invalid input/output shape, schema mismatch, contract violation", "term": "Failure modes" }, { "description": "[runtime-validation](/records/reasoning/technique-runtime-validation), [contract-testing](/records/reasoning/technique-contract-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "payload models declaredSchema", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-interface-correctness", "title": "interface-correctness" }, { "blocks": [ { "items": [ "Dimension: [relation](/records/reasoning/dimension-relation)", "Lens: [relational](/records/reasoning/lens-relation)", "Invariant: [correct-interactions](/records/reasoning/invariant-correct-interactions)", "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)" ], "kind": "list" }, { "entries": [ { "description": "An interaction is the connection between two components, so the surface checks each request against the response its counterpart owes.", "term": "Fit" }, { "description": "wrong API response, incorrect UI behavior, invalid component communication", "term": "Failure modes" }, { "description": "[end-to-end-testing](/records/reasoning/technique-end-to-end-testing), [contract-testing](/records/reasoning/technique-contract-testing), [integration-testing](/records/reasoning/technique-integration-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "response = contract(request)", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-interaction-correctness", "title": "interaction-correctness" }, { "blocks": [ { "items": [ "Dimension: [time](/records/reasoning/dimension-time)", "Lens: [temporal](/records/reasoning/lens-time)", "Invariant: [acceptable-execution-time](/records/reasoning/invariant-acceptable-execution-time)", "Predicate: [bound](/records/vocabulary/predicate-type-bound)" ], "kind": "list" }, { "entries": [ { "description": "Execution time is a duration measured across a run, so the surface compares elapsed time with the deadline.", "term": "Fit" }, { "description": "timeout, deadline miss, stale data, starvation", "term": "Failure modes" }, { "description": "[load-testing](/records/reasoning/technique-load-testing), [monitoring](/records/reasoning/technique-monitoring), [tracing](/records/reasoning/technique-tracing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "elapsed <= deadline", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-temporal-correctness", "title": "temporal-correctness" }, { "blocks": [ { "items": [ "Dimension: [behavior](/records/reasoning/dimension-behavior)", "Lens: [temporal](/records/reasoning/lens-time)", "Invariant: [safe-concurrent-behavior](/records/reasoning/invariant-safe-concurrent-behavior)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "Concurrent code misbehaves only in particular interleavings, so the surface examines what the system does across the orderings time allows.", "term": "Fit" }, { "description": "race conditions, deadlocks, livelocks, ordering failures", "term": "Failure modes" }, { "description": "[stress-testing](/records/reasoning/technique-stress-testing), [deterministic-replay](/records/reasoning/technique-deterministic-replay)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "for-all interleavings: linearizable(history)", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-concurrency-correctness", "title": "concurrency-correctness" }, { "blocks": [ { "items": [ "Dimension: [composition](/records/reasoning/dimension-composition)", "Lens: [evolutionary](/records/reasoning/lens-change)", "Invariant: [controlled-memory-usage](/records/reasoning/invariant-controlled-memory-usage)", "Predicate: [bound](/records/vocabulary/predicate-type-bound)" ], "kind": "list" }, { "entries": [ { "description": "A leak shows as the live set growing in content over a long run, so the surface tracks what memory holds as the run develops.", "term": "Fit" }, { "description": "memory leaks, excessive allocation, fragmentation, retention bugs", "term": "Failure modes" }, { "description": "[heap-analysis](/records/reasoning/technique-heap-analysis), [profiling](/records/reasoning/technique-profiling)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "liveSet bounded as t grows and retained delta approaches 0", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-memory-correctness", "title": "memory-correctness" }, { "blocks": [ { "items": [ "Dimension: [composition](/records/reasoning/dimension-composition)", "Lens: [behavioral](/records/reasoning/lens-behavior)", "Invariant: [acceptable-resource-consumption](/records/reasoning/invariant-acceptable-resource-consumption)", "Predicate: [absence](/records/vocabulary/predicate-type-absence)" ], "kind": "list" }, { "entries": [ { "description": "A handle leak is a resource the system acquires and never gives back, so the surface pairs each acquisition with its release.", "term": "Fit" }, { "description": "file/socket/connection/handle leaks", "term": "Failure modes" }, { "description": "[monitoring](/records/reasoning/technique-monitoring), [assertion-checking](/records/reasoning/technique-assertion-checking)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "acquired = released (no leaked handles)", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-resource-correctness", "title": "resource-correctness" }, { "blocks": [ { "items": [ "Dimension: [scale](/records/reasoning/dimension-scale)", "Lens: [statistical](/records/reasoning/lens-statistical)", "Invariant: [acceptable-execution-time](/records/reasoning/invariant-acceptable-execution-time)", "Predicate: [bound](/records/vocabulary/predicate-type-bound)" ], "kind": "list" }, { "entries": [ { "description": "Performance depends on load, and one request says little about it, so the surface reads latency and throughput as distributions over many requests.", "term": "Fit" }, { "description": "slow algorithms, excessive CPU, high latency, throughput degradation", "term": "Failure modes" }, { "description": "[profiling](/records/reasoning/technique-profiling), [load-testing](/records/reasoning/technique-load-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "latency_p99 <= budget and throughput >= floor", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-performance-correctness", "title": "performance-correctness" }, { "blocks": [ { "items": [ "Dimension: [probability](/records/reasoning/dimension-probability)", "Lens: [anomaly](/records/reasoning/lens-anomaly)", "Invariant: [reliability-under-faults](/records/reasoning/invariant-reliability-under-faults)", "Predicate: [absence](/records/vocabulary/predicate-type-absence)" ], "kind": "list" }, { "entries": [ { "description": "A crash is a rare departure from normal running, so the surface looks for the inputs and faults that make it likely.", "term": "Fit" }, { "description": "crashes, unhandled exceptions, process termination", "term": "Failure modes" }, { "description": "[chaos-testing](/records/reasoning/technique-chaos-testing), [fault-injection](/records/reasoning/technique-fault-injection), [monitoring](/records/reasoning/technique-monitoring)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "no input leads to an unhandled fault", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-reliability-correctness", "title": "reliability-correctness" }, { "blocks": [ { "items": [ "Dimension: [probability](/records/reasoning/dimension-probability)", "Lens: [temporal](/records/reasoning/lens-time)", "Invariant: [availability-under-stress](/records/reasoning/invariant-availability-under-stress)", "Predicate: [bound](/records/vocabulary/predicate-type-bound)" ], "kind": "list" }, { "entries": [ { "description": "Availability is the share of time the service answers, so the surface measures uptime over a period under a declared fault set.", "term": "Fit" }, { "description": "service outage, cascading failure, degraded service", "term": "Failure modes" }, { "description": "[chaos-testing](/records/reasoning/technique-chaos-testing), [fault-injection](/records/reasoning/technique-fault-injection)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "uptime >= SLO under the declared fault set", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-availability-correctness", "title": "availability-correctness" }, { "blocks": [ { "items": [ "Dimension: [relation](/records/reasoning/dimension-relation)", "Lens: [statistical](/records/reasoning/lens-statistical)", "Invariant: [consistency-across-components](/records/reasoning/invariant-consistency-across-components)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "Replicas agree or drift as a population, so the surface compares the state of every copy with the others.", "term": "Fit" }, { "description": "stale cache, divergent replicas, invalid synchronization", "term": "Failure modes" }, { "description": "[differential-testing](/records/reasoning/technique-differential-testing), [assertion-checking](/records/reasoning/technique-assertion-checking)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "for-all replicas: converge(state)", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-consistency-correctness", "title": "consistency-correctness" }, { "blocks": [ { "items": [ "Dimension: [identity](/records/reasoning/dimension-identity)", "Lens: [structural](/records/reasoning/lens-structure)", "Invariant: [correct-outputs](/records/reasoning/invariant-correct-outputs)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "Persisted data is correct when each record is still the same record in the same shape, so the surface checks identity and layout across writes and migrations.", "term": "Fit" }, { "description": "corrupted persistence, invalid migrations, duplicate records", "term": "Failure modes" }, { "description": "[assertion-checking](/records/reasoning/technique-assertion-checking), [integration-testing](/records/reasoning/technique-integration-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "persisted = written and migrate then inverse = identity", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-data-correctness", "title": "data-correctness" }, { "blocks": [ { "items": [ "Dimension: [scale](/records/reasoning/dimension-scale)", "Lens: [anomaly](/records/reasoning/lens-anomaly)", "Invariant: [numerical-validity](/records/reasoning/invariant-numerical-validity)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "Numbers fail at the edges of their range, so the surface looks for the magnitudes where a result overflows, loses precision or turns into NaN.", "term": "Fit" }, { "description": "overflow, precision loss, NaN propagation", "term": "Failure modes" }, { "description": "[property-based-testing](/records/reasoning/technique-property-based-testing), [static-analysis](/records/reasoning/technique-static-analysis)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "result is finite and not overflow and not NaN", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-numerical-correctness", "title": "numerical-correctness" }, { "blocks": [ { "items": [ "Dimension: [cause](/records/reasoning/dimension-cause)", "Lens: [causal](/records/reasoning/lens-cause)", "Invariant: [security-boundaries](/records/reasoning/invariant-security-boundaries)", "Predicate: [absence](/records/vocabulary/predicate-type-absence)" ], "kind": "list" }, { "entries": [ { "description": "An exploit is a chain from an input to an effect the boundary should prevent, so the surface traces what each input can cause.", "term": "Fit" }, { "description": "injection, privilege escalation, unsafe deserialization", "term": "Failure modes" }, { "description": "[static-analysis](/records/reasoning/technique-static-analysis), [fuzz-testing](/records/reasoning/technique-fuzz-testing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "no input yields privilege escalation or injection", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-security-correctness", "title": "security-correctness" }, { "blocks": [ { "items": [ "Dimension: [novelty](/records/reasoning/dimension-novelty)", "Lens: [anomaly](/records/reasoning/lens-anomaly)", "Invariant: [deterministic-behavior-where-required](/records/reasoning/invariant-deterministic-behavior-where-required)", "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)" ], "kind": "list" }, { "entries": [ { "description": "Nondeterminism appears as an output that differs from the one expected for the same input, so the surface repeats runs and looks for the deviation.", "term": "Fit" }, { "description": "the same input producing different outputs", "term": "Failure modes" }, { "description": "[property-based-testing](/records/reasoning/technique-property-based-testing), [deterministic-replay](/records/reasoning/technique-deterministic-replay)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "f(x) = f(x) across runs", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-determinism-correctness", "title": "determinism-correctness" }, { "blocks": [ { "items": [ "Dimension: [relation](/records/reasoning/dimension-relation)", "Lens: [sequential](/records/reasoning/lens-sequential)", "Invariant: [protocol-compliance](/records/reasoning/invariant-protocol-compliance)", "Predicate: [temporal-order](/records/vocabulary/predicate-type-temporal-order)" ], "kind": "list" }, { "entries": [ { "description": "A protocol is a relation between parties that holds only in a given order of messages, so the surface checks the sequence against the protocol's grammar.", "term": "Fit" }, { "description": "invalid message ordering, malformed communication sequence", "term": "Failure modes" }, { "description": "[contract-testing](/records/reasoning/technique-contract-testing), [model-checking](/records/reasoning/technique-model-checking)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "messageSeq in protocolGrammar", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-protocol-correctness", "title": "protocol-correctness" }, { "blocks": [ { "items": [ "Dimension: [state](/records/reasoning/dimension-state)", "Lens: [structural](/records/reasoning/lens-structure)", "Invariant: [configuration-validity](/records/reasoning/invariant-configuration-validity)", "Predicate: [schema](/records/vocabulary/predicate-type-schema)" ], "kind": "list" }, { "entries": [ { "description": "Configuration is the condition a deployment starts in, and it is valid when its keys and values take the declared shape, so the surface checks it against its schema.", "term": "Fit" }, { "description": "invalid environment variables, feature flag errors, deployment mismatch", "term": "Failure modes" }, { "description": "[runtime-validation](/records/reasoning/technique-runtime-validation), [static-analysis](/records/reasoning/technique-static-analysis)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "config models configSchema", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-configuration-correctness", "title": "configuration-correctness" }, { "blocks": [ { "items": [ "Dimension: [meaning](/records/reasoning/dimension-meaning)", "Lens: [frequency](/records/reasoning/lens-frequency)", "Invariant: [accurate-observability](/records/reasoning/invariant-accurate-observability)", "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)" ], "kind": "list" }, { "entries": [ { "description": "A signal is accurate when every event it stands for is emitted each time the event occurs, so the surface compares how often events happen with how often they are reported.", "term": "Fit" }, { "description": "missing logs, incorrect metrics, broken traces", "term": "Failure modes" }, { "description": "[monitoring](/records/reasoning/technique-monitoring), [tracing](/records/reasoning/technique-tracing)", "term": "Techniques" }, { "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)", "term": "Predicate grounds" }, { "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required", "term": "Evidence" }, { "description": "[ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Evidence grounds" }, { "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)", "term": "Verdicts" } ], "kind": "glossary" }, { "code": "for-all event: emitted and measurable", "kind": "code", "language": "text", "title": "Predicate" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered", "term": "Checked by" }, { "description": "Every module that declares the surface covered, and the code under that module", "term": "Population" }, { "description": "A verdict stands until the module's code, its declaration or the surface changes", "term": "Freshness" }, { "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass", "term": "Refusal" }, { "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean", "term": "Evidence" }, { "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-test-surface-observability-correctness", "title": "observability-correctness" } ], "title": "The test surfaces" }, { "icon": "bi-signpost-split", "id": "the-techniques", "intro": "Each technique a surface is observed by works in one reasoning mode and is listed with the surfaces that use it.", "subsections": [ { "blocks": [ { "items": [ "Mode: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [ { "description": "Reads structure and types for defects before execution", "term": "Principle" }, { "description": "[Static Analysis](/records/architecture/static-analysis)", "term": "Refused by rules" }, { "description": "Reports nothing when its rule never visits the construct, as with a misspelled visitor key", "term": "Goes silent when" }, { "description": "[numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-static-analysis", "title": "static-analysis" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Compares observed with expected results on an isolated unit", "term": "Principle" }, { "description": "Passes when the doubles that isolate the unit no longer behave like the real collaborators", "term": "Goes silent when" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-unit-testing", "title": "unit-testing" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Compares observed with expected results across cooperating parts", "term": "Principle" }, { "description": "Passes on an environment that differs from production in the part that fails", "term": "Goes silent when" }, { "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-integration-testing", "title": "integration-testing" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Compares observed with expected results on the whole system", "term": "Principle" }, { "description": "Is retried until it passes, so an intermittent failure is read as noise", "term": "Goes silent when" }, { "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-end-to-end-testing", "title": "end-to-end-testing" }, { "blocks": [ { "items": [ "Mode: [classification](/records/reasoning/mode-classification)" ], "kind": "list" }, { "entries": [ { "description": "Asserts that an invariant holds across a generated input space", "term": "Principle" }, { "description": "[Property-Based Testing](/records/architecture/property-based-testing)", "term": "Refused by rules" }, { "description": "Passes when the generator never produces the inputs that break the property", "term": "Goes silent when" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-property-based-testing", "title": "property-based-testing" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Compares observed results with a reference implementation, the oracle", "term": "Principle" }, { "description": "Passes when the reference implementation shares the defect", "term": "Goes silent when" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-differential-testing", "title": "differential-testing" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Compares an observed interface with an agreed contract", "term": "Principle" }, { "description": "Passes against a copy of the contract that drifted from the one the provider serves", "term": "Goes silent when" }, { "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-contract-testing", "title": "contract-testing" }, { "blocks": [ { "items": [ "Mode: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [ { "description": "Checks boundary data against its declared shape at runtime", "term": "Principle" }, { "description": "Never runs on a path that reaches the core without crossing the boundary", "term": "Goes silent when" }, { "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-runtime-validation", "title": "runtime-validation" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Checks a runtime condition against an assumed invariant", "term": "Principle" }, { "description": "Is compiled out or disabled in the build that runs in production", "term": "Goes silent when" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-assertion-checking", "title": "assertion-checking" }, { "blocks": [ { "items": [ "Mode: [creation](/records/reasoning/mode-creation)" ], "kind": "list" }, { "entries": [ { "description": "Generates adversarial inputs to provoke unhandled failures", "term": "Principle" }, { "description": "Stops before the generated inputs reach the failing region, and the run reports no crash", "term": "Goes silent when" }, { "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-fuzz-testing", "title": "fuzz-testing" }, { "blocks": [ { "items": [ "Mode: [prediction](/records/reasoning/mode-prediction)" ], "kind": "list" }, { "entries": [ { "description": "Projects behavior under expected demand", "term": "Principle" }, { "description": "Runs a workload shaped unlike real demand", "term": "Goes silent when" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-load-testing", "title": "load-testing" }, { "blocks": [ { "items": [ "Mode: [prediction](/records/reasoning/mode-prediction)" ], "kind": "list" }, { "entries": [ { "description": "Projects behavior past its limits to expose timing and ordering defects", "term": "Principle" }, { "description": "Ends at a limit below the one production reaches", "term": "Goes silent when" }, { "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-stress-testing", "title": "stress-testing" }, { "blocks": [ { "items": [ "Mode: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [ { "description": "Measures the distribution of execution cost", "term": "Principle" }, { "description": "[Profiling](/records/architecture/profiling)", "term": "Refused by rules" }, { "description": "Samples too coarsely to see a short, frequent cost", "term": "Goes silent when" }, { "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-profiling", "title": "profiling" }, { "blocks": [ { "items": [ "Mode: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [ { "description": "Measures allocation and retention over time", "term": "Principle" }, { "description": "Measures a run too short for retention to show", "term": "Goes silent when" }, { "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-heap-analysis", "title": "heap-analysis" }, { "blocks": [ { "items": [ "Mode: [description](/records/reasoning/mode-description)" ], "kind": "list" }, { "entries": [ { "description": "Describes the runtime flow across components", "term": "Principle" }, { "description": "Loses spans at an uninstrumented hop, and the trace reads as complete", "term": "Goes silent when" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-tracing", "title": "tracing" }, { "blocks": [ { "items": [ "Mode: [intervention](/records/reasoning/mode-intervention)" ], "kind": "list" }, { "entries": [ { "description": "Induces a failure and observes the response", "term": "Principle" }, { "description": "Injects only the faults the developer anticipated", "term": "Goes silent when" }, { "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-fault-injection", "title": "fault-injection" }, { "blocks": [ { "items": [ "Mode: [intervention](/records/reasoning/mode-intervention)" ], "kind": "list" }, { "entries": [ { "description": "Induces random failures and observes how the system recovers", "term": "Principle" }, { "description": "Runs where the dependency that fails in production is absent", "term": "Goes silent when" }, { "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-chaos-testing", "title": "chaos-testing" }, { "blocks": [ { "items": [ "Mode: [explanation](/records/reasoning/mode-explanation)" ], "kind": "list" }, { "entries": [ { "description": "Proves that a property holds across the reachable state space", "term": "Principle" }, { "description": "Proves the model while the code drifts away from it", "term": "Goes silent when" }, { "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-model-checking", "title": "model-checking" }, { "blocks": [ { "items": [ "Mode: [reflection](/records/reasoning/mode-reflection)" ], "kind": "list" }, { "entries": [ { "description": "Reproduces a run to isolate a non-deterministic cause", "term": "Principle" }, { "description": "Replays a recording that left out the source of the non-determinism", "term": "Goes silent when" }, { "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-deterministic-replay", "title": "deterministic-replay" }, { "blocks": [ { "items": [ "Mode: [observation](/records/reasoning/mode-observation)" ], "kind": "list" }, { "entries": [ { "description": "Observes live behavior for deviations from normal", "term": "Principle" }, { "description": "[Monitoring](/records/architecture/monitoring)", "term": "Refused by rules" }, { "description": "Reports no deviation because the signal it watches was never emitted", "term": "Goes silent when" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-monitoring", "title": "monitoring" }, { "blocks": [ { "items": [ "Mode: [intervention](/records/reasoning/mode-intervention)" ], "kind": "list" }, { "entries": [ { "description": "Introduces a deliberate defect and checks that the tests or the rule report it", "term": "Principle" }, { "description": "Counts a mutant as caught by a test that fails for an unrelated reason", "term": "Goes silent when" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-mutation-testing", "title": "mutation-testing" }, { "blocks": [ { "items": [ "Mode: [comparison](/records/reasoning/mode-comparison)" ], "kind": "list" }, { "entries": [ { "description": "Reads back what was written and compares it with what was meant to be written", "term": "Principle" }, { "description": "Reads from a cache or a buffer instead of the store the write reached", "term": "Goes silent when" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows", "term": "Checked by" }, { "description": "Every surface that lists the technique, and the code those surfaces cover", "term": "Population" }, { "description": "A verdict stands until the technique, a surface that lists it or the covered code changes", "term": "Freshness" }, { "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails", "term": "Refusal" }, { "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean", "term": "Evidence" }, { "description": "The technique record, which every surface that lists it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-technique-read-after-write-verification", "title": "read-after-write-verification" } ], "title": "The techniques" }, { "icon": "bi-signpost-split", "id": "the-invariants", "intro": "Each invariant the test surfaces assert is listed with the surfaces that assert it.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Outputs are correct", "term": "Invariant" }, { "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-correct-outputs", "title": "Correct Outputs" }, { "blocks": [ { "entries": [ { "description": "State evolves correctly", "term": "Invariant" }, { "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-correct-state-evolution", "title": "Correct State Evolution" }, { "blocks": [ { "entries": [ { "description": "State transitions are valid", "term": "Invariant" }, { "description": "[state-correctness](/records/reasoning/test-surface-state-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-valid-state-transitions", "title": "Valid State Transitions" }, { "blocks": [ { "entries": [ { "description": "Interactions between components are correct", "term": "Invariant" }, { "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-correct-interactions", "title": "Correct Interactions" }, { "blocks": [ { "entries": [ { "description": "Interfaces and contracts are valid", "term": "Invariant" }, { "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-valid-interfaces-and-contracts", "title": "Valid Interfaces and Contracts" }, { "blocks": [ { "entries": [ { "description": "Execution time is acceptable", "term": "Invariant" }, { "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-acceptable-execution-time", "title": "Acceptable Execution Time" }, { "blocks": [ { "entries": [ { "description": "Resource consumption is acceptable", "term": "Invariant" }, { "description": "[resource-correctness](/records/reasoning/test-surface-resource-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-acceptable-resource-consumption", "title": "Acceptable Resource Consumption" }, { "blocks": [ { "entries": [ { "description": "Concurrent behavior is safe", "term": "Invariant" }, { "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-safe-concurrent-behavior", "title": "Safe Concurrent Behavior" }, { "blocks": [ { "entries": [ { "description": "Memory usage is controlled", "term": "Invariant" }, { "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-controlled-memory-usage", "title": "Controlled Memory Usage" }, { "blocks": [ { "entries": [ { "description": "The system stays reliable under faults", "term": "Invariant" }, { "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-reliability-under-faults", "title": "Reliability Under Faults" }, { "blocks": [ { "entries": [ { "description": "The system stays available under stress", "term": "Invariant" }, { "description": "[availability-correctness](/records/reasoning/test-surface-availability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-availability-under-stress", "title": "Availability Under Stress" }, { "blocks": [ { "entries": [ { "description": "Components stay consistent with each other", "term": "Invariant" }, { "description": "[consistency-correctness](/records/reasoning/test-surface-consistency-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-consistency-across-components", "title": "Consistency Across Components" }, { "blocks": [ { "entries": [ { "description": "Behavior is deterministic where determinism is required", "term": "Invariant" }, { "description": "[determinism-correctness](/records/reasoning/test-surface-determinism-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-deterministic-behavior-where-required", "title": "Required Determinism" }, { "blocks": [ { "entries": [ { "description": "Numerical results are valid", "term": "Invariant" }, { "description": "[numerical-correctness](/records/reasoning/test-surface-numerical-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-numerical-validity", "title": "Numerical Validity" }, { "blocks": [ { "entries": [ { "description": "Security boundaries hold", "term": "Invariant" }, { "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-security-boundaries", "title": "Security Boundaries" }, { "blocks": [ { "entries": [ { "description": "Communication complies with its protocol", "term": "Invariant" }, { "description": "[protocol-correctness](/records/reasoning/test-surface-protocol-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-protocol-compliance", "title": "Protocol Compliance" }, { "blocks": [ { "entries": [ { "description": "Configuration is valid", "term": "Invariant" }, { "description": "[configuration-correctness](/records/reasoning/test-surface-configuration-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-configuration-validity", "title": "Configuration Validity" }, { "blocks": [ { "entries": [ { "description": "Logs, metrics and traces report the system accurately", "term": "Invariant" }, { "description": "[observability-correctness](/records/reasoning/test-surface-observability-correctness)", "term": "Surfaces" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-accurate-observability", "title": "Accurate Observability" }, { "blocks": [ { "entries": [ { "description": "Every representation in jurisdiction has a computable check", "term": "Invariant" }, { "description": "[meta_field](/records/pag/production-meta-field)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-reachable-check", "title": "Reachable Check" }, { "blocks": [ { "entries": [ { "description": "A check's domain is explicit and reported beside its verdict", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-declared-domain", "title": "Declared Domain" }, { "blocks": [ { "entries": [ { "description": "A dependency is declared by the referent, never inferred from a name", "term": "Invariant" }, { "description": "[dag_declaration](/records/pag/production-dag-declaration), [edge_clause](/records/pag/production-edge-clause)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-declared-dependency", "title": "Declared Dependency" }, { "blocks": [ { "entries": [ { "description": "A verdict is itself a representation and has a reachable check of its own", "term": "Invariant" }, { "description": "[report_block](/records/pag/production-report-block)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-verdict-is-representation", "title": "Checked Verdict" }, { "blocks": [ { "entries": [ { "description": "A lowering keeps every distinction a later check needs", "term": "Invariant" }, { "description": "[preserves_clause](/records/pag/production-preserves-clause)", "term": "Grounded by" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-preserved-distinction", "title": "Preserved Distinction" }, { "blocks": [ { "entries": [ { "description": "A check reads a representation derived after the last relevant mutator", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-fresh-read", "title": "Fresh Read" }, { "blocks": [ { "entries": [ { "description": "One canonical question has one authoritative derivation", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-one-derivation", "title": "One Derivation" }, { "blocks": [ { "entries": [ { "description": "A chain is as certain as its least certain link, and a link below the floor is removed from the chain", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-weakest-link", "title": "Weakest Link" }, { "blocks": [ { "entries": [ { "description": "Dynamic observation locates a failure and never certifies absence", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-observation-locates", "title": "Observation Scope" }, { "blocks": [ { "entries": [ { "description": "A run stops when saturation, completion and verification all hold, or when it is blocked on something outside it", "term": "Invariant" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground", "term": "Checked by" }, { "description": "Every test surface and document construct that names the invariant", "term": "Population" }, { "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes", "term": "Freshness" }, { "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause", "term": "Refusal" }, { "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence", "term": "Observation" }, { "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean", "term": "Evidence" }, { "description": "The invariant record, which every surface and document construct that asserts it cites", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-invariant-epi-terminate-on-three", "title": "Three-Condition Stop" } ], "title": "The invariants" }, { "icon": "bi-signpost-split", "id": "the-failure-shapes", "intro": "Each failure shape names a way a check goes wrong without failing, the invariant it breaks, its fix, the records it shows up in and the quality rules that refuse it.", "subsections": [ { "blocks": [ { "entries": [ { "description": "A representation that no check reaches.", "term": "Shape" }, { "description": "Declare the representation into a check's jurisdiction, or state in writing that it lies outside it.", "term": "Fix" }, { "description": "[epi-reachable-check](/records/reasoning/invariant-epi-reachable-check)", "term": "Breaks" }, { "description": "[Manual-Only Governance](/records/architecture/manual-only-governance), [Unobservable Failure](/records/architecture/unobservable-failure), [Untested Implementation](/records/lexicon/untested-implementation)", "term": "Seen in" }, { "description": "None, because whether a representation is reachable is a property of the gate's jurisdiction, which no source rule sees", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-no-reachable-check", "title": "No reachable check" }, { "blocks": [ { "entries": [ { "description": "A check that ran over an empty domain and reported a pass.", "term": "Shape" }, { "description": "Report the population beside every rate, and confirm at start-up that every name the check uses resolves.", "term": "Fix" }, { "description": "[epi-declared-domain](/records/reasoning/invariant-epi-declared-domain)", "term": "Breaks" }, { "description": "[Silent Failure](/records/lexicon/silent-failure)", "term": "Seen in" }, { "description": "empty-block, exception-handling", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-empty-domain", "title": "Empty domain" }, { "blocks": [ { "entries": [ { "description": "A parent counted as read while its children were never read.", "term": "Shape" }, { "description": "Subtract the read set from the child set and report what remains.", "term": "Fix" }, { "description": "[epi-declared-domain](/records/reasoning/invariant-epi-declared-domain)", "term": "Breaks" }, { "description": "None, because a read set is known only while the run executes", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-spent-parent", "title": "Spent parent" }, { "blocks": [ { "entries": [ { "description": "A dependency created because two names share a word.", "term": "Shape" }, { "description": "Join on the id the referent declares.", "term": "Fix" }, { "description": "[epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Breaks" }, { "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)", "term": "Seen in" }, { "description": "None, because a join on spelling reads like any other string comparison in source", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-edge-from-spelling", "title": "Edge from spelling" }, { "blocks": [ { "entries": [ { "description": "A node inside the graph that is trusted without a check, such as an exit code or a modification time.", "term": "Shape" }, { "description": "Route the node through a check that can fail, and disclose what no check can reach.", "term": "Fix" }, { "description": "[epi-verdict-is-representation](/records/reasoning/invariant-epi-verdict-is-representation)", "term": "Breaks" }, { "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization), [Mock Mirage](/records/architecture/mock-mirage), [Security Theater](/records/architecture/security-theater)", "term": "Seen in" }, { "description": "error-handling", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-trusted-leaf", "title": "Trusted leaf" }, { "blocks": [ { "entries": [ { "description": "A reshaped representation that dropped a distinction a later check needs.", "term": "Shape" }, { "description": "Keep the distinction, and refuse at the writer anything the layout cannot express.", "term": "Fix" }, { "description": "[epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)", "term": "Breaks" }, { "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift), [Schema Drift](/records/architecture/schema-drift), [Silent Data Corruption](/records/architecture/silent-data-corruption)", "term": "Seen in" }, { "description": "type-safety", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-lossy-lowering", "title": "Lossy lowering" }, { "blocks": [ { "entries": [ { "description": "A check that reads a representation the run already changed.", "term": "Shape" }, { "description": "Derive after the last mutator, and decide freshness by the fingerprint of the inputs and the code.", "term": "Fix" }, { "description": "[epi-fresh-read](/records/reasoning/invariant-epi-fresh-read)", "term": "Breaks" }, { "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)", "term": "Seen in" }, { "description": "None, because no catalogued rule refuses a cache keyed by time or by lifetime alone", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-stale-read", "title": "Stale read" }, { "blocks": [ { "entries": [ { "description": "One question answered by two derivations that can drift apart.", "term": "Shape" }, { "description": "Collapse them to one derivation, computed by the producer of the answer.", "term": "Fix" }, { "description": "[epi-one-derivation](/records/reasoning/invariant-epi-one-derivation)", "term": "Breaks" }, { "description": "[Duplicated Authority](/records/lexicon/duplicated-authority)", "term": "Seen in" }, { "description": "duplicate-code", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-two-derivations", "title": "Two derivations" }, { "blocks": [ { "entries": [ { "description": "A link below the certainty floor kept in a chain with a flag on it.", "term": "Shape" }, { "description": "Remove the link from the chain.", "term": "Fix" }, { "description": "[epi-weakest-link](/records/reasoning/invariant-epi-weakest-link)", "term": "Breaks" }, { "description": "None, because the certainty of a link is a property of the chain, which no source rule sees", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-weak-link-kept", "title": "Weak link kept" }, { "blocks": [ { "entries": [ { "description": "No observed failure read as proof that no failure exists.", "term": "Shape" }, { "description": "Use the observation to locate failures, and leave the verdict on absence to a check.", "term": "Fix" }, { "description": "[epi-observation-locates](/records/reasoning/invariant-epi-observation-locates)", "term": "Breaks" }, { "description": "None, because the shape lies in how a report is read, not in source", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-absence-certified-by-observation", "title": "Absence certified by observation" }, { "blocks": [ { "entries": [ { "description": "A run that stops because the model is confident, before completion, saturation and verification hold.", "term": "Shape" }, { "description": "Stop only when the three conditions hold, or when the run is blocked on something outside it.", "term": "Fix" }, { "description": "[epi-terminate-on-three](/records/reasoning/invariant-epi-terminate-on-three)", "term": "Breaks" }, { "description": "None, because the shape lies in how a run decides to stop, not in source", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-stop-on-confidence", "title": "Stop on confidence" }, { "blocks": [ { "entries": [ { "description": "A threshold set below what its population already meets, so the check it guards cannot fail until most of the population is gone.", "term": "Shape" }, { "description": "Set the floor from the population as it stands, and plant a case below it to watch the check fail.", "term": "Fix" }, { "description": "[epi-verdict-is-representation](/records/reasoning/invariant-epi-verdict-is-representation)", "term": "Breaks" }, { "description": "None, because whether a floor can be reached is a property of the population, which no source rule sees", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-unfailable-floor", "title": "Unfailable floor" }, { "blocks": [ { "entries": [ { "description": "A tool named as a verifier that reports no pass, no fail and no exit code, so what it examines has no check at all.", "term": "Shape" }, { "description": "Give the tool a verdict and an exit code, or rename it to the probe it is.", "term": "Fix" }, { "description": "[epi-reachable-check](/records/reasoning/invariant-epi-reachable-check)", "term": "Breaks" }, { "description": "None, because whether a tool issues a verdict is a property of its output contract, which no source rule sees", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-verdictless-verifier", "title": "Verdictless verifier" }, { "blocks": [ { "entries": [ { "description": "A kind of construct the index a family of checks reads never records, so every check over that index misses every construct of the kind.", "term": "Shape" }, { "description": "Record the kind in the index, and confirm that a planted construct of the kind is reported.", "term": "Fix" }, { "description": "[epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)", "term": "Breaks" }, { "description": "None, because an index's coverage of construct kinds is a property of its builder, which no source rule sees", "term": "Refused by rules" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen", "term": "Checked by" }, { "description": "Every source file the named rules lint, and every failure a check or a review classifies", "term": "Population" }, { "description": "A verdict stands until the linted source, a named rule or the shape's instances change", "term": "Freshness" }, { "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it", "term": "Refusal" }, { "description": "The runtime observations that locate a failure, which are then filed under a shape", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean", "term": "Evidence" }, { "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "reasoning-failure-shape-unindexed-construct-kind", "title": "Unindexed construct kind" } ], "title": "Failure shapes" }, { "icon": "bi-signpost-split", "id": "the-uncovered-cells", "intro": "These cells of the dimension and lens grid are not yet covered by any surface. The list is derived from the grid and the surfaces, never stored.", "subsections": [ { "blocks": [ { "entries": [ { "description": "[identity](/records/reasoning/dimension-identity) through [temporal](/records/reasoning/lens-time)", "term": "identity through temporal" }, { "description": "[identity](/records/reasoning/dimension-identity) through [spatial](/records/reasoning/lens-space)", "term": "identity through spatial" }, { "description": "[identity](/records/reasoning/dimension-identity) through [statistical](/records/reasoning/lens-statistical)", "term": "identity through statistical" }, { "description": "[identity](/records/reasoning/dimension-identity) through [frequency](/records/reasoning/lens-frequency)", "term": "identity through frequency" }, { "description": "[identity](/records/reasoning/dimension-identity) through [sequential](/records/reasoning/lens-sequential)", "term": "identity through sequential" }, { "description": "[identity](/records/reasoning/dimension-identity) through [relational](/records/reasoning/lens-relation)", "term": "identity through relational" }, { "description": "[identity](/records/reasoning/dimension-identity) through [behavioral](/records/reasoning/lens-behavior)", "term": "identity through behavioral" }, { "description": "[identity](/records/reasoning/dimension-identity) through [functional](/records/reasoning/lens-function)", "term": "identity through functional" }, { "description": "[identity](/records/reasoning/dimension-identity) through [semantic](/records/reasoning/lens-meaning)", "term": "identity through semantic" }, { "description": "[identity](/records/reasoning/dimension-identity) through [causal](/records/reasoning/lens-cause)", "term": "identity through causal" }, { "description": "[identity](/records/reasoning/dimension-identity) through [predictive](/records/reasoning/lens-prediction)", "term": "identity through predictive" }, { "description": "[identity](/records/reasoning/dimension-identity) through [anomaly](/records/reasoning/lens-anomaly)", "term": "identity through anomaly" }, { "description": "[identity](/records/reasoning/dimension-identity) through [evolutionary](/records/reasoning/lens-change)", "term": "identity through evolutionary" }, { "description": "[identity](/records/reasoning/dimension-identity) through [fractal](/records/reasoning/lens-fractal)", "term": "identity through fractal" }, { "description": "[identity](/records/reasoning/dimension-identity) through [transformational](/records/reasoning/lens-transformation)", "term": "identity through transformational" }, { "description": "[identity](/records/reasoning/dimension-identity) through [invariant](/records/reasoning/lens-invariant)", "term": "identity through invariant" }, { "description": "[identity](/records/reasoning/dimension-identity) through [optimization](/records/reasoning/lens-optimization)", "term": "identity through optimization" }, { "description": "[identity](/records/reasoning/dimension-identity) through [complexity](/records/reasoning/lens-complexity)", "term": "identity through complexity" }, { "description": "[composition](/records/reasoning/dimension-composition) through [structural](/records/reasoning/lens-structure)", "term": "composition through structural" }, { "description": "[composition](/records/reasoning/dimension-composition) through [temporal](/records/reasoning/lens-time)", "term": "composition through temporal" }, { "description": "[composition](/records/reasoning/dimension-composition) through [spatial](/records/reasoning/lens-space)", "term": "composition through spatial" }, { "description": "[composition](/records/reasoning/dimension-composition) through [statistical](/records/reasoning/lens-statistical)", "term": "composition through statistical" }, { "description": "[composition](/records/reasoning/dimension-composition) through [frequency](/records/reasoning/lens-frequency)", "term": "composition through frequency" }, { "description": "[composition](/records/reasoning/dimension-composition) through [sequential](/records/reasoning/lens-sequential)", "term": "composition through sequential" }, { "description": "[composition](/records/reasoning/dimension-composition) through [relational](/records/reasoning/lens-relation)", "term": "composition through relational" }, { "description": "[composition](/records/reasoning/dimension-composition) through [functional](/records/reasoning/lens-function)", "term": "composition through functional" }, { "description": "[composition](/records/reasoning/dimension-composition) through [semantic](/records/reasoning/lens-meaning)", "term": "composition through semantic" }, { "description": "[composition](/records/reasoning/dimension-composition) through [causal](/records/reasoning/lens-cause)", "term": "composition through causal" }, { "description": "[composition](/records/reasoning/dimension-composition) through [predictive](/records/reasoning/lens-prediction)", "term": "composition through predictive" }, { "description": "[composition](/records/reasoning/dimension-composition) through [anomaly](/records/reasoning/lens-anomaly)", "term": "composition through anomaly" }, { "description": "[composition](/records/reasoning/dimension-composition) through [fractal](/records/reasoning/lens-fractal)", "term": "composition through fractal" }, { "description": "[composition](/records/reasoning/dimension-composition) through [transformational](/records/reasoning/lens-transformation)", "term": "composition through transformational" }, { "description": "[composition](/records/reasoning/dimension-composition) through [invariant](/records/reasoning/lens-invariant)", "term": "composition through invariant" }, { "description": "[composition](/records/reasoning/dimension-composition) through [optimization](/records/reasoning/lens-optimization)", "term": "composition through optimization" }, { "description": "[composition](/records/reasoning/dimension-composition) through [complexity](/records/reasoning/lens-complexity)", "term": "composition through complexity" }, { "description": "[structure](/records/reasoning/dimension-structure) through [temporal](/records/reasoning/lens-time)", "term": "structure through temporal" }, { "description": "[structure](/records/reasoning/dimension-structure) through [spatial](/records/reasoning/lens-space)", "term": "structure through spatial" }, { "description": "[structure](/records/reasoning/dimension-structure) through [statistical](/records/reasoning/lens-statistical)", "term": "structure through statistical" }, { "description": "[structure](/records/reasoning/dimension-structure) through [frequency](/records/reasoning/lens-frequency)", "term": "structure through frequency" }, { "description": "[structure](/records/reasoning/dimension-structure) through [sequential](/records/reasoning/lens-sequential)", "term": "structure through sequential" }, { "description": "[structure](/records/reasoning/dimension-structure) through [relational](/records/reasoning/lens-relation)", "term": "structure through relational" }, { "description": "[structure](/records/reasoning/dimension-structure) through [behavioral](/records/reasoning/lens-behavior)", "term": "structure through behavioral" }, { "description": "[structure](/records/reasoning/dimension-structure) through [functional](/records/reasoning/lens-function)", "term": "structure through functional" }, { "description": "[structure](/records/reasoning/dimension-structure) through [semantic](/records/reasoning/lens-meaning)", "term": "structure through semantic" }, { "description": "[structure](/records/reasoning/dimension-structure) through [causal](/records/reasoning/lens-cause)", "term": "structure through causal" }, { "description": "[structure](/records/reasoning/dimension-structure) through [predictive](/records/reasoning/lens-prediction)", "term": "structure through predictive" }, { "description": "[structure](/records/reasoning/dimension-structure) through [anomaly](/records/reasoning/lens-anomaly)", "term": "structure through anomaly" }, { "description": "[structure](/records/reasoning/dimension-structure) through [evolutionary](/records/reasoning/lens-change)", "term": "structure through evolutionary" }, { "description": "[structure](/records/reasoning/dimension-structure) through [fractal](/records/reasoning/lens-fractal)", "term": "structure through fractal" }, { "description": "[structure](/records/reasoning/dimension-structure) through [transformational](/records/reasoning/lens-transformation)", "term": "structure through transformational" }, { "description": "[structure](/records/reasoning/dimension-structure) through [invariant](/records/reasoning/lens-invariant)", "term": "structure through invariant" }, { "description": "[structure](/records/reasoning/dimension-structure) through [optimization](/records/reasoning/lens-optimization)", "term": "structure through optimization" }, { "description": "[structure](/records/reasoning/dimension-structure) through [complexity](/records/reasoning/lens-complexity)", "term": "structure through complexity" }, { "description": "[relation](/records/reasoning/dimension-relation) through [structural](/records/reasoning/lens-structure)", "term": "relation through structural" }, { "description": "[relation](/records/reasoning/dimension-relation) through [temporal](/records/reasoning/lens-time)", "term": "relation through temporal" }, { "description": "[relation](/records/reasoning/dimension-relation) through [spatial](/records/reasoning/lens-space)", "term": "relation through spatial" }, { "description": "[relation](/records/reasoning/dimension-relation) through [frequency](/records/reasoning/lens-frequency)", "term": "relation through frequency" }, { "description": "[relation](/records/reasoning/dimension-relation) through [behavioral](/records/reasoning/lens-behavior)", "term": "relation through behavioral" }, { "description": "[relation](/records/reasoning/dimension-relation) through [functional](/records/reasoning/lens-function)", "term": "relation through functional" }, { "description": "[relation](/records/reasoning/dimension-relation) through [semantic](/records/reasoning/lens-meaning)", "term": "relation through semantic" }, { "description": "[relation](/records/reasoning/dimension-relation) through [causal](/records/reasoning/lens-cause)", "term": "relation through causal" }, { "description": "[relation](/records/reasoning/dimension-relation) through [predictive](/records/reasoning/lens-prediction)", "term": "relation through predictive" }, { "description": "[relation](/records/reasoning/dimension-relation) through [anomaly](/records/reasoning/lens-anomaly)", "term": "relation through anomaly" }, { "description": "[relation](/records/reasoning/dimension-relation) through [evolutionary](/records/reasoning/lens-change)", "term": "relation through evolutionary" }, { "description": "[relation](/records/reasoning/dimension-relation) through [fractal](/records/reasoning/lens-fractal)", "term": "relation through fractal" }, { "description": "[relation](/records/reasoning/dimension-relation) through [transformational](/records/reasoning/lens-transformation)", "term": "relation through transformational" }, { "description": "[relation](/records/reasoning/dimension-relation) through [invariant](/records/reasoning/lens-invariant)", "term": "relation through invariant" }, { "description": "[relation](/records/reasoning/dimension-relation) through [optimization](/records/reasoning/lens-optimization)", "term": "relation through optimization" }, { "description": "[relation](/records/reasoning/dimension-relation) through [complexity](/records/reasoning/lens-complexity)", "term": "relation through complexity" }, { "description": "[space](/records/reasoning/dimension-space) through [structural](/records/reasoning/lens-structure)", "term": "space through structural" }, { "description": "[space](/records/reasoning/dimension-space) through [temporal](/records/reasoning/lens-time)", "term": "space through temporal" }, { "description": "[space](/records/reasoning/dimension-space) through [spatial](/records/reasoning/lens-space)", "term": "space through spatial" }, { "description": "[space](/records/reasoning/dimension-space) through [statistical](/records/reasoning/lens-statistical)", "term": "space through statistical" }, { "description": "[space](/records/reasoning/dimension-space) through [frequency](/records/reasoning/lens-frequency)", "term": "space through frequency" }, { "description": "[space](/records/reasoning/dimension-space) through [sequential](/records/reasoning/lens-sequential)", "term": "space through sequential" }, { "description": "[space](/records/reasoning/dimension-space) through [relational](/records/reasoning/lens-relation)", "term": "space through relational" }, { "description": "[space](/records/reasoning/dimension-space) through [behavioral](/records/reasoning/lens-behavior)", "term": "space through behavioral" }, { "description": "[space](/records/reasoning/dimension-space) through [functional](/records/reasoning/lens-function)", "term": "space through functional" }, { "description": "[space](/records/reasoning/dimension-space) through [semantic](/records/reasoning/lens-meaning)", "term": "space through semantic" }, { "description": "[space](/records/reasoning/dimension-space) through [causal](/records/reasoning/lens-cause)", "term": "space through causal" }, { "description": "[space](/records/reasoning/dimension-space) through [predictive](/records/reasoning/lens-prediction)", "term": "space through predictive" }, { "description": "[space](/records/reasoning/dimension-space) through [anomaly](/records/reasoning/lens-anomaly)", "term": "space through anomaly" }, { "description": "[space](/records/reasoning/dimension-space) through [evolutionary](/records/reasoning/lens-change)", "term": "space through evolutionary" }, { "description": "[space](/records/reasoning/dimension-space) through [fractal](/records/reasoning/lens-fractal)", "term": "space through fractal" }, { "description": "[space](/records/reasoning/dimension-space) through [transformational](/records/reasoning/lens-transformation)", "term": "space through transformational" }, { "description": "[space](/records/reasoning/dimension-space) through [invariant](/records/reasoning/lens-invariant)", "term": "space through invariant" }, { "description": "[space](/records/reasoning/dimension-space) through [optimization](/records/reasoning/lens-optimization)", "term": "space through optimization" }, { "description": "[space](/records/reasoning/dimension-space) through [complexity](/records/reasoning/lens-complexity)", "term": "space through complexity" }, { "description": "[time](/records/reasoning/dimension-time) through [structural](/records/reasoning/lens-structure)", "term": "time through structural" }, { "description": "[time](/records/reasoning/dimension-time) through [spatial](/records/reasoning/lens-space)", "term": "time through spatial" }, { "description": "[time](/records/reasoning/dimension-time) through [statistical](/records/reasoning/lens-statistical)", "term": "time through statistical" }, { "description": "[time](/records/reasoning/dimension-time) through [frequency](/records/reasoning/lens-frequency)", "term": "time through frequency" }, { "description": "[time](/records/reasoning/dimension-time) through [sequential](/records/reasoning/lens-sequential)", "term": "time through sequential" }, { "description": "[time](/records/reasoning/dimension-time) through [relational](/records/reasoning/lens-relation)", "term": "time through relational" }, { "description": "[time](/records/reasoning/dimension-time) through [behavioral](/records/reasoning/lens-behavior)", "term": "time through behavioral" }, { "description": "[time](/records/reasoning/dimension-time) through [functional](/records/reasoning/lens-function)", "term": "time through functional" }, { "description": "[time](/records/reasoning/dimension-time) through [semantic](/records/reasoning/lens-meaning)", "term": "time through semantic" }, { "description": "[time](/records/reasoning/dimension-time) through [causal](/records/reasoning/lens-cause)", "term": "time through causal" }, { "description": "[time](/records/reasoning/dimension-time) through [predictive](/records/reasoning/lens-prediction)", "term": "time through predictive" }, { "description": "[time](/records/reasoning/dimension-time) through [anomaly](/records/reasoning/lens-anomaly)", "term": "time through anomaly" }, { "description": "[time](/records/reasoning/dimension-time) through [evolutionary](/records/reasoning/lens-change)", "term": "time through evolutionary" }, { "description": "[time](/records/reasoning/dimension-time) through [fractal](/records/reasoning/lens-fractal)", "term": "time through fractal" }, { "description": "[time](/records/reasoning/dimension-time) through [transformational](/records/reasoning/lens-transformation)", "term": "time through transformational" }, { "description": "[time](/records/reasoning/dimension-time) through [invariant](/records/reasoning/lens-invariant)", "term": "time through invariant" }, { "description": "[time](/records/reasoning/dimension-time) through [optimization](/records/reasoning/lens-optimization)", "term": "time through optimization" }, { "description": "[time](/records/reasoning/dimension-time) through [complexity](/records/reasoning/lens-complexity)", "term": "time through complexity" }, { "description": "[state](/records/reasoning/dimension-state) through [temporal](/records/reasoning/lens-time)", "term": "state through temporal" }, { "description": "[state](/records/reasoning/dimension-state) through [spatial](/records/reasoning/lens-space)", "term": "state through spatial" }, { "description": "[state](/records/reasoning/dimension-state) through [statistical](/records/reasoning/lens-statistical)", "term": "state through statistical" }, { "description": "[state](/records/reasoning/dimension-state) through [frequency](/records/reasoning/lens-frequency)", "term": "state through frequency" }, { "description": "[state](/records/reasoning/dimension-state) through [relational](/records/reasoning/lens-relation)", "term": "state through relational" }, { "description": "[state](/records/reasoning/dimension-state) through [behavioral](/records/reasoning/lens-behavior)", "term": "state through behavioral" }, { "description": "[state](/records/reasoning/dimension-state) through [functional](/records/reasoning/lens-function)", "term": "state through functional" }, { "description": "[state](/records/reasoning/dimension-state) through [semantic](/records/reasoning/lens-meaning)", "term": "state through semantic" }, { "description": "[state](/records/reasoning/dimension-state) through [causal](/records/reasoning/lens-cause)", "term": "state through causal" }, { "description": "[state](/records/reasoning/dimension-state) through [predictive](/records/reasoning/lens-prediction)", "term": "state through predictive" }, { "description": "[state](/records/reasoning/dimension-state) through [anomaly](/records/reasoning/lens-anomaly)", "term": "state through anomaly" }, { "description": "[state](/records/reasoning/dimension-state) through [evolutionary](/records/reasoning/lens-change)", "term": "state through evolutionary" }, { "description": "[state](/records/reasoning/dimension-state) through [fractal](/records/reasoning/lens-fractal)", "term": "state through fractal" }, { "description": "[state](/records/reasoning/dimension-state) through [transformational](/records/reasoning/lens-transformation)", "term": "state through transformational" }, { "description": "[state](/records/reasoning/dimension-state) through [invariant](/records/reasoning/lens-invariant)", "term": "state through invariant" }, { "description": "[state](/records/reasoning/dimension-state) through [optimization](/records/reasoning/lens-optimization)", "term": "state through optimization" }, { "description": "[state](/records/reasoning/dimension-state) through [complexity](/records/reasoning/lens-complexity)", "term": "state through complexity" }, { "description": "[change](/records/reasoning/dimension-change) through [structural](/records/reasoning/lens-structure)", "term": "change through structural" }, { "description": "[change](/records/reasoning/dimension-change) through [temporal](/records/reasoning/lens-time)", "term": "change through temporal" }, { "description": "[change](/records/reasoning/dimension-change) through [spatial](/records/reasoning/lens-space)", "term": "change through spatial" }, { "description": "[change](/records/reasoning/dimension-change) through [statistical](/records/reasoning/lens-statistical)", "term": "change through statistical" }, { "description": "[change](/records/reasoning/dimension-change) through [frequency](/records/reasoning/lens-frequency)", "term": "change through frequency" }, { "description": "[change](/records/reasoning/dimension-change) through [sequential](/records/reasoning/lens-sequential)", "term": "change through sequential" }, { "description": "[change](/records/reasoning/dimension-change) through [relational](/records/reasoning/lens-relation)", "term": "change through relational" }, { "description": "[change](/records/reasoning/dimension-change) through [behavioral](/records/reasoning/lens-behavior)", "term": "change through behavioral" }, { "description": "[change](/records/reasoning/dimension-change) through [functional](/records/reasoning/lens-function)", "term": "change through functional" }, { "description": "[change](/records/reasoning/dimension-change) through [semantic](/records/reasoning/lens-meaning)", "term": "change through semantic" }, { "description": "[change](/records/reasoning/dimension-change) through [causal](/records/reasoning/lens-cause)", "term": "change through causal" }, { "description": "[change](/records/reasoning/dimension-change) through [predictive](/records/reasoning/lens-prediction)", "term": "change through predictive" }, { "description": "[change](/records/reasoning/dimension-change) through [anomaly](/records/reasoning/lens-anomaly)", "term": "change through anomaly" }, { "description": "[change](/records/reasoning/dimension-change) through [evolutionary](/records/reasoning/lens-change)", "term": "change through evolutionary" }, { "description": "[change](/records/reasoning/dimension-change) through [fractal](/records/reasoning/lens-fractal)", "term": "change through fractal" }, { "description": "[change](/records/reasoning/dimension-change) through [transformational](/records/reasoning/lens-transformation)", "term": "change through transformational" }, { "description": "[change](/records/reasoning/dimension-change) through [invariant](/records/reasoning/lens-invariant)", "term": "change through invariant" }, { "description": "[change](/records/reasoning/dimension-change) through [optimization](/records/reasoning/lens-optimization)", "term": "change through optimization" }, { "description": "[change](/records/reasoning/dimension-change) through [complexity](/records/reasoning/lens-complexity)", "term": "change through complexity" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [structural](/records/reasoning/lens-structure)", "term": "behavior through structural" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [spatial](/records/reasoning/lens-space)", "term": "behavior through spatial" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [statistical](/records/reasoning/lens-statistical)", "term": "behavior through statistical" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [frequency](/records/reasoning/lens-frequency)", "term": "behavior through frequency" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [sequential](/records/reasoning/lens-sequential)", "term": "behavior through sequential" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [relational](/records/reasoning/lens-relation)", "term": "behavior through relational" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [behavioral](/records/reasoning/lens-behavior)", "term": "behavior through behavioral" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [functional](/records/reasoning/lens-function)", "term": "behavior through functional" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [semantic](/records/reasoning/lens-meaning)", "term": "behavior through semantic" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [causal](/records/reasoning/lens-cause)", "term": "behavior through causal" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [predictive](/records/reasoning/lens-prediction)", "term": "behavior through predictive" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [anomaly](/records/reasoning/lens-anomaly)", "term": "behavior through anomaly" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [evolutionary](/records/reasoning/lens-change)", "term": "behavior through evolutionary" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [fractal](/records/reasoning/lens-fractal)", "term": "behavior through fractal" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [transformational](/records/reasoning/lens-transformation)", "term": "behavior through transformational" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [invariant](/records/reasoning/lens-invariant)", "term": "behavior through invariant" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [optimization](/records/reasoning/lens-optimization)", "term": "behavior through optimization" }, { "description": "[behavior](/records/reasoning/dimension-behavior) through [complexity](/records/reasoning/lens-complexity)", "term": "behavior through complexity" }, { "description": "[function](/records/reasoning/dimension-function) through [structural](/records/reasoning/lens-structure)", "term": "function through structural" }, { "description": "[function](/records/reasoning/dimension-function) through [temporal](/records/reasoning/lens-time)", "term": "function through temporal" }, { "description": "[function](/records/reasoning/dimension-function) through [spatial](/records/reasoning/lens-space)", "term": "function through spatial" }, { "description": "[function](/records/reasoning/dimension-function) through [statistical](/records/reasoning/lens-statistical)", "term": "function through statistical" }, { "description": "[function](/records/reasoning/dimension-function) through [frequency](/records/reasoning/lens-frequency)", "term": "function through frequency" }, { "description": "[function](/records/reasoning/dimension-function) through [sequential](/records/reasoning/lens-sequential)", "term": "function through sequential" }, { "description": "[function](/records/reasoning/dimension-function) through [relational](/records/reasoning/lens-relation)", "term": "function through relational" }, { "description": "[function](/records/reasoning/dimension-function) through [functional](/records/reasoning/lens-function)", "term": "function through functional" }, { "description": "[function](/records/reasoning/dimension-function) through [semantic](/records/reasoning/lens-meaning)", "term": "function through semantic" }, { "description": "[function](/records/reasoning/dimension-function) through [causal](/records/reasoning/lens-cause)", "term": "function through causal" }, { "description": "[function](/records/reasoning/dimension-function) through [predictive](/records/reasoning/lens-prediction)", "term": "function through predictive" }, { "description": "[function](/records/reasoning/dimension-function) through [anomaly](/records/reasoning/lens-anomaly)", "term": "function through anomaly" }, { "description": "[function](/records/reasoning/dimension-function) through [evolutionary](/records/reasoning/lens-change)", "term": "function through evolutionary" }, { "description": "[function](/records/reasoning/dimension-function) through [fractal](/records/reasoning/lens-fractal)", "term": "function through fractal" }, { "description": "[function](/records/reasoning/dimension-function) through [transformational](/records/reasoning/lens-transformation)", "term": "function through transformational" }, { "description": "[function](/records/reasoning/dimension-function) through [invariant](/records/reasoning/lens-invariant)", "term": "function through invariant" }, { "description": "[function](/records/reasoning/dimension-function) through [optimization](/records/reasoning/lens-optimization)", "term": "function through optimization" }, { "description": "[function](/records/reasoning/dimension-function) through [complexity](/records/reasoning/lens-complexity)", "term": "function through complexity" }, { "description": "[cause](/records/reasoning/dimension-cause) through [structural](/records/reasoning/lens-structure)", "term": "cause through structural" }, { "description": "[cause](/records/reasoning/dimension-cause) through [temporal](/records/reasoning/lens-time)", "term": "cause through temporal" }, { "description": "[cause](/records/reasoning/dimension-cause) through [spatial](/records/reasoning/lens-space)", "term": "cause through spatial" }, { "description": "[cause](/records/reasoning/dimension-cause) through [statistical](/records/reasoning/lens-statistical)", "term": "cause through statistical" }, { "description": "[cause](/records/reasoning/dimension-cause) through [frequency](/records/reasoning/lens-frequency)", "term": "cause through frequency" }, { "description": "[cause](/records/reasoning/dimension-cause) through [sequential](/records/reasoning/lens-sequential)", "term": "cause through sequential" }, { "description": "[cause](/records/reasoning/dimension-cause) through [relational](/records/reasoning/lens-relation)", "term": "cause through relational" }, { "description": "[cause](/records/reasoning/dimension-cause) through [behavioral](/records/reasoning/lens-behavior)", "term": "cause through behavioral" }, { "description": "[cause](/records/reasoning/dimension-cause) through [functional](/records/reasoning/lens-function)", "term": "cause through functional" }, { "description": "[cause](/records/reasoning/dimension-cause) through [semantic](/records/reasoning/lens-meaning)", "term": "cause through semantic" }, { "description": "[cause](/records/reasoning/dimension-cause) through [predictive](/records/reasoning/lens-prediction)", "term": "cause through predictive" }, { "description": "[cause](/records/reasoning/dimension-cause) through [anomaly](/records/reasoning/lens-anomaly)", "term": "cause through anomaly" }, { "description": "[cause](/records/reasoning/dimension-cause) through [evolutionary](/records/reasoning/lens-change)", "term": "cause through evolutionary" }, { "description": "[cause](/records/reasoning/dimension-cause) through [fractal](/records/reasoning/lens-fractal)", "term": "cause through fractal" }, { "description": "[cause](/records/reasoning/dimension-cause) through [transformational](/records/reasoning/lens-transformation)", "term": "cause through transformational" }, { "description": "[cause](/records/reasoning/dimension-cause) through [invariant](/records/reasoning/lens-invariant)", "term": "cause through invariant" }, { "description": "[cause](/records/reasoning/dimension-cause) through [optimization](/records/reasoning/lens-optimization)", "term": "cause through optimization" }, { "description": "[cause](/records/reasoning/dimension-cause) through [complexity](/records/reasoning/lens-complexity)", "term": "cause through complexity" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [structural](/records/reasoning/lens-structure)", "term": "meaning through structural" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [temporal](/records/reasoning/lens-time)", "term": "meaning through temporal" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [spatial](/records/reasoning/lens-space)", "term": "meaning through spatial" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [statistical](/records/reasoning/lens-statistical)", "term": "meaning through statistical" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [sequential](/records/reasoning/lens-sequential)", "term": "meaning through sequential" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [relational](/records/reasoning/lens-relation)", "term": "meaning through relational" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [behavioral](/records/reasoning/lens-behavior)", "term": "meaning through behavioral" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [functional](/records/reasoning/lens-function)", "term": "meaning through functional" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [causal](/records/reasoning/lens-cause)", "term": "meaning through causal" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [predictive](/records/reasoning/lens-prediction)", "term": "meaning through predictive" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [anomaly](/records/reasoning/lens-anomaly)", "term": "meaning through anomaly" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [evolutionary](/records/reasoning/lens-change)", "term": "meaning through evolutionary" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [fractal](/records/reasoning/lens-fractal)", "term": "meaning through fractal" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [transformational](/records/reasoning/lens-transformation)", "term": "meaning through transformational" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [invariant](/records/reasoning/lens-invariant)", "term": "meaning through invariant" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [optimization](/records/reasoning/lens-optimization)", "term": "meaning through optimization" }, { "description": "[meaning](/records/reasoning/dimension-meaning) through [complexity](/records/reasoning/lens-complexity)", "term": "meaning through complexity" }, { "description": "[scale](/records/reasoning/dimension-scale) through [structural](/records/reasoning/lens-structure)", "term": "scale through structural" }, { "description": "[scale](/records/reasoning/dimension-scale) through [temporal](/records/reasoning/lens-time)", "term": "scale through temporal" }, { "description": "[scale](/records/reasoning/dimension-scale) through [spatial](/records/reasoning/lens-space)", "term": "scale through spatial" }, { "description": "[scale](/records/reasoning/dimension-scale) through [frequency](/records/reasoning/lens-frequency)", "term": "scale through frequency" }, { "description": "[scale](/records/reasoning/dimension-scale) through [sequential](/records/reasoning/lens-sequential)", "term": "scale through sequential" }, { "description": "[scale](/records/reasoning/dimension-scale) through [relational](/records/reasoning/lens-relation)", "term": "scale through relational" }, { "description": "[scale](/records/reasoning/dimension-scale) through [behavioral](/records/reasoning/lens-behavior)", "term": "scale through behavioral" }, { "description": "[scale](/records/reasoning/dimension-scale) through [functional](/records/reasoning/lens-function)", "term": "scale through functional" }, { "description": "[scale](/records/reasoning/dimension-scale) through [semantic](/records/reasoning/lens-meaning)", "term": "scale through semantic" }, { "description": "[scale](/records/reasoning/dimension-scale) through [causal](/records/reasoning/lens-cause)", "term": "scale through causal" }, { "description": "[scale](/records/reasoning/dimension-scale) through [predictive](/records/reasoning/lens-prediction)", "term": "scale through predictive" }, { "description": "[scale](/records/reasoning/dimension-scale) through [evolutionary](/records/reasoning/lens-change)", "term": "scale through evolutionary" }, { "description": "[scale](/records/reasoning/dimension-scale) through [fractal](/records/reasoning/lens-fractal)", "term": "scale through fractal" }, { "description": "[scale](/records/reasoning/dimension-scale) through [transformational](/records/reasoning/lens-transformation)", "term": "scale through transformational" }, { "description": "[scale](/records/reasoning/dimension-scale) through [invariant](/records/reasoning/lens-invariant)", "term": "scale through invariant" }, { "description": "[scale](/records/reasoning/dimension-scale) through [optimization](/records/reasoning/lens-optimization)", "term": "scale through optimization" }, { "description": "[scale](/records/reasoning/dimension-scale) through [complexity](/records/reasoning/lens-complexity)", "term": "scale through complexity" }, { "description": "[probability](/records/reasoning/dimension-probability) through [structural](/records/reasoning/lens-structure)", "term": "probability through structural" }, { "description": "[probability](/records/reasoning/dimension-probability) through [spatial](/records/reasoning/lens-space)", "term": "probability through spatial" }, { "description": "[probability](/records/reasoning/dimension-probability) through [statistical](/records/reasoning/lens-statistical)", "term": "probability through statistical" }, { "description": "[probability](/records/reasoning/dimension-probability) through [frequency](/records/reasoning/lens-frequency)", "term": "probability through frequency" }, { "description": "[probability](/records/reasoning/dimension-probability) through [sequential](/records/reasoning/lens-sequential)", "term": "probability through sequential" }, { "description": "[probability](/records/reasoning/dimension-probability) through [relational](/records/reasoning/lens-relation)", "term": "probability through relational" }, { "description": "[probability](/records/reasoning/dimension-probability) through [behavioral](/records/reasoning/lens-behavior)", "term": "probability through behavioral" }, { "description": "[probability](/records/reasoning/dimension-probability) through [functional](/records/reasoning/lens-function)", "term": "probability through functional" }, { "description": "[probability](/records/reasoning/dimension-probability) through [semantic](/records/reasoning/lens-meaning)", "term": "probability through semantic" }, { "description": "[probability](/records/reasoning/dimension-probability) through [causal](/records/reasoning/lens-cause)", "term": "probability through causal" }, { "description": "[probability](/records/reasoning/dimension-probability) through [predictive](/records/reasoning/lens-prediction)", "term": "probability through predictive" }, { "description": "[probability](/records/reasoning/dimension-probability) through [evolutionary](/records/reasoning/lens-change)", "term": "probability through evolutionary" }, { "description": "[probability](/records/reasoning/dimension-probability) through [fractal](/records/reasoning/lens-fractal)", "term": "probability through fractal" }, { "description": "[probability](/records/reasoning/dimension-probability) through [transformational](/records/reasoning/lens-transformation)", "term": "probability through transformational" }, { "description": "[probability](/records/reasoning/dimension-probability) through [invariant](/records/reasoning/lens-invariant)", "term": "probability through invariant" }, { "description": "[probability](/records/reasoning/dimension-probability) through [optimization](/records/reasoning/lens-optimization)", "term": "probability through optimization" }, { "description": "[probability](/records/reasoning/dimension-probability) through [complexity](/records/reasoning/lens-complexity)", "term": "probability through complexity" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [structural](/records/reasoning/lens-structure)", "term": "novelty through structural" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [temporal](/records/reasoning/lens-time)", "term": "novelty through temporal" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [spatial](/records/reasoning/lens-space)", "term": "novelty through spatial" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [statistical](/records/reasoning/lens-statistical)", "term": "novelty through statistical" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [frequency](/records/reasoning/lens-frequency)", "term": "novelty through frequency" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [sequential](/records/reasoning/lens-sequential)", "term": "novelty through sequential" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [relational](/records/reasoning/lens-relation)", "term": "novelty through relational" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [behavioral](/records/reasoning/lens-behavior)", "term": "novelty through behavioral" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [functional](/records/reasoning/lens-function)", "term": "novelty through functional" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [semantic](/records/reasoning/lens-meaning)", "term": "novelty through semantic" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [causal](/records/reasoning/lens-cause)", "term": "novelty through causal" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [predictive](/records/reasoning/lens-prediction)", "term": "novelty through predictive" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [evolutionary](/records/reasoning/lens-change)", "term": "novelty through evolutionary" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [fractal](/records/reasoning/lens-fractal)", "term": "novelty through fractal" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [transformational](/records/reasoning/lens-transformation)", "term": "novelty through transformational" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [invariant](/records/reasoning/lens-invariant)", "term": "novelty through invariant" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [optimization](/records/reasoning/lens-optimization)", "term": "novelty through optimization" }, { "description": "[novelty](/records/reasoning/dimension-novelty) through [complexity](/records/reasoning/lens-complexity)", "term": "novelty through complexity" } ], "kind": "glossary" } ], "title": "The uncovered cells" } ], "title": "The uncovered cells" }, { "icon": "bi-signpost-split", "id": "the-maps", "intro": "The reasoning collection carries these maps beside its records, namely the foundation sequence with the math types on each of its layers, the invariant groups, and the operations a pattern admits.", "subsections": [ { "blocks": [ { "entries": [ { "description": "logic-set-theory-axioms → structure → change → relationships → possibility → application", "term": "Foundation sequence" } ], "kind": "glossary" } ], "title": "Foundation sequence" }, { "blocks": [ { "entries": [ { "description": "[algebra](/records/reasoning/math-type-algebra), geometry", "term": "structure" }, { "description": "[analysis](/records/reasoning/math-type-analysis), dynamics", "term": "change" }, { "description": "category-theory, [information-theory](/records/reasoning/math-type-information-theory)", "term": "relationships" }, { "description": "[probability](/records/reasoning/math-type-probability), [computation](/records/reasoning/math-type-computation), complexity", "term": "possibility" } ], "kind": "glossary" } ], "title": "Foundation layers" }, { "blocks": [ { "entries": [ { "description": "objects, relations, transformations, constraints, [emergence](/records/reasoning/substrate-node-emergence)", "term": "generative" }, { "description": "entity, [relation](/records/reasoning/substrate-node-relation), state, [transformation](/records/reasoning/substrate-node-transformation), [constraint](/records/reasoning/substrate-node-constraint), [information](/records/reasoning/substrate-node-information), feedback, [emergence](/records/reasoning/substrate-node-emergence)", "term": "systemic" } ], "kind": "glossary" } ], "title": "Invariant groups" }, { "blocks": [ { "entries": [ { "description": "detection, classification, explanation, prediction, generation", "term": "Members" } ], "kind": "glossary" } ], "title": "Pattern operations" } ], "title": "The maps" }, { "icon": "bi-signpost-split", "id": "the-groundings", "intro": "Every grounding edge the reasoning collection declares is listed with the record it leaves from and the record or grammar it lands on, or with the label it carries where it names a rule rather than a record.", "subsections": [ { "blocks": [ { "entries": [ { "description": "[ver-evidence](/records/reasoning/node-ver-evidence) → Carries: an unverified claim carries no weight", "term": "ver-evidence" }, { "description": "[constrain](/records/stage/constrain) → Lands on: [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)", "term": "constrain" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop) → Lands on: [Checklist Creation Kernel](/records/algorithms/checklist-creation-kernel)", "term": "derivation-loop" }, { "description": "[derivation-loop](/records/reasoning/loop-derivation-loop) → Lands on: [checklist](/records/pag/template-checklist)", "term": "derivation-loop" } ], "kind": "glossary" } ], "title": "The groundings" } ], "title": "The groundings" } ] }, { "icon": "bi-braces", "id": "grammar", "label": "Grammar", "layout": "ontology", "sections": [ { "icon": "bi-code-square", "id": "pag-keywords-action", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Input acquisition · lowers to READ_RESOURCE", "term": "Meaning" }, { "description": "READ file INTO data", "term": "Example" }, { "description": "[mode:observation](/records/reasoning/mode-observation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-read", "title": "READ" }, { "blocks": [ { "entries": [ { "description": "Output generation · lowers to PERSIST_ARTIFACT", "term": "Meaning" }, { "description": "WRITE content TO file", "term": "Example" }, { "description": "[axis:formalization](/records/reasoning/axis-formalization)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-write", "title": "WRITE" }, { "blocks": [ { "entries": [ { "description": "Action invocation · lowers to EXECUTE_TOOL", "term": "Meaning" }, { "description": "EXECUTE command WITH params", "term": "Example" }, { "description": "[axis:formalization](/records/reasoning/axis-formalization)", "term": "Grounds" }, { "description": "[EXECUTES](/records/pag/keyword-executes): EXECUTE is an action a step invokes, while EXECUTES is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-execute", "title": "EXECUTE" }, { "blocks": [ { "entries": [ { "description": "Construction · lowers to COMPOSE_ARTIFACT", "term": "Meaning" }, { "description": "CREATE artifact FROM template", "term": "Example" }, { "description": "[mode:construction](/records/reasoning/mode-construction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-create", "title": "CREATE" }, { "blocks": [ { "entries": [ { "description": "Removal · an irreversible write, refused before it lands", "term": "Meaning" }, { "description": "DELETE file_path", "term": "Example" }, { "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-delete", "title": "DELETE" }, { "blocks": [ { "entries": [ { "description": "Discovery · lowers to DISCOVER_RESOURCES", "term": "Meaning" }, { "description": "FIND pattern IN scope", "term": "Example" }, { "description": "[mode:observation](/records/reasoning/mode-observation)", "term": "Grounds" }, { "description": "[FINDS](/records/pag/keyword-finds): FIND is an action a step invokes, while FINDS is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-find", "title": "FIND" }, { "blocks": [ { "entries": [ { "description": "Inspection · lowers to ANALYZE_CONTENT", "term": "Meaning" }, { "description": "ANALYZE target FOR condition", "term": "Example" }, { "description": "[mode:observation](/records/reasoning/mode-observation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-analyze", "title": "ANALYZE" }, { "blocks": [ { "entries": [ { "description": "Verification · lowers to VALIDATE_ARTIFACT", "term": "Meaning" }, { "description": "VALIDATE state AGAINST schema", "term": "Example" }, { "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-validate", "title": "VALIDATE" }, { "blocks": [ { "entries": [ { "description": "Confirmation against evidence", "term": "Meaning" }, { "description": "VERIFY condition", "term": "Example" }, { "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" }, { "description": "[VERIFIES](/records/pag/keyword-verifies): VERIFY is an action a step invokes, while VERIFIES is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-verify", "title": "VERIFY" }, { "blocks": [ { "entries": [ { "description": "Isolation · lowers to EXTRACT_FACTS", "term": "Meaning" }, { "description": "EXTRACT data FROM source", "term": "Example" }, { "description": "[mode:abstraction](/records/reasoning/mode-abstraction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-extract", "title": "EXTRACT" }, { "blocks": [ { "entries": [ { "description": "Aggregation", "term": "Meaning" }, { "description": "COLLECT items INTO container", "term": "Example" }, { "description": "[mode:abstraction](/records/reasoning/mode-abstraction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-collect", "title": "COLLECT" }, { "blocks": [ { "entries": [ { "description": "Selection", "term": "Meaning" }, { "description": "FILTER items WHERE condition", "term": "Example" }, { "description": "[mode:classification](/records/reasoning/mode-classification)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-filter", "title": "FILTER" }, { "blocks": [ { "entries": [ { "description": "Comparison", "term": "Meaning" }, { "description": "COMPARE a AGAINST b", "term": "Example" }, { "description": "[mode:comparison](/records/reasoning/mode-comparison)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-compare", "title": "COMPARE" }, { "blocks": [ { "entries": [ { "description": "Transformation · a lowering that names what it preserves", "term": "Meaning" }, { "description": "CONVERT data TO format", "term": "Example" }, { "description": "[invariant:epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-convert", "title": "CONVERT" }, { "blocks": [ { "entries": [ { "description": "Combination", "term": "Meaning" }, { "description": "MERGE sources INTO target", "term": "Example" }, { "description": "[mode:abstraction](/records/reasoning/mode-abstraction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-merge", "title": "MERGE" }, { "blocks": [ { "entries": [ { "description": "Division", "term": "Meaning" }, { "description": "SPLIT data BY delimiter", "term": "Example" }, { "description": "[substrate-node:difference](/records/reasoning/substrate-node-difference)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-split", "title": "SPLIT" }, { "blocks": [ { "entries": [ { "description": "Ordering", "term": "Meaning" }, { "description": "SORT items BY criteria", "term": "Example" }, { "description": "[lens:sequential](/records/reasoning/lens-sequential)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-sort", "title": "SORT" }, { "blocks": [ { "entries": [ { "description": "Prioritization · the ranking a worth gate reads", "term": "Meaning" }, { "description": "RANK items BY score", "term": "Example" }, { "description": "[node:tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-rank", "title": "RANK" }, { "blocks": [ { "entries": [ { "description": "Association · a declared edge, never a name match", "term": "Meaning" }, { "description": "LINK source TO target", "term": "Example" }, { "description": "[lens:relation](/records/reasoning/lens-relation), [invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-link", "title": "LINK" }, { "blocks": [ { "entries": [ { "description": "Output · lowers to REPORT_RESULT", "term": "Meaning" }, { "description": "REPORT findings", "term": "Example" }, { "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-report", "title": "REPORT" }, { "blocks": [ { "entries": [ { "description": "Add to collection", "term": "Meaning" }, { "description": "ADD item TO list", "term": "Example" }, { "description": "[substrate-node:existence](/records/reasoning/substrate-node-existence)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-add", "title": "ADD" }, { "blocks": [ { "entries": [ { "description": "Append to end", "term": "Meaning" }, { "description": "APPEND value TO array", "term": "Example" }, { "description": "[substrate-node:existence](/records/reasoning/substrate-node-existence)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-append", "title": "APPEND" }, { "blocks": [ { "entries": [ { "description": "Insert at position", "term": "Meaning" }, { "description": "INSERT item AT index", "term": "Example" }, { "description": "[substrate-node:structure](/records/reasoning/substrate-node-structure)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-insert", "title": "INSERT" }, { "blocks": [ { "entries": [ { "description": "Remove from collection", "term": "Meaning" }, { "description": "REMOVE item FROM list", "term": "Example" }, { "description": "[substrate-node:difference](/records/reasoning/substrate-node-difference)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-remove", "title": "REMOVE" }, { "blocks": [ { "entries": [ { "description": "Relocation · a create at the destination, read before it lands", "term": "Meaning" }, { "description": "MOVE file TO destination", "term": "Example" }, { "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-move", "title": "MOVE" }, { "blocks": [ { "entries": [ { "description": "Duplication · a second derivation of one fact, declared as such", "term": "Meaning" }, { "description": "COPY file TO backup", "term": "Example" }, { "description": "[invariant:epi-one-derivation](/records/reasoning/invariant-epi-one-derivation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-copy", "title": "COPY" }, { "blocks": [ { "entries": [ { "description": "Preservation of the last accepted state before a mutation", "term": "Meaning" }, { "description": "BACKUP file TO location", "term": "Example" }, { "description": "[node:ter-promotion](/records/reasoning/node-ter-promotion)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-backup", "title": "BACKUP" }, { "blocks": [ { "entries": [ { "description": "Recovery of the last accepted state", "term": "Meaning" }, { "description": "RESTORE FROM backup", "term": "Example" }, { "description": "[node:ter-promotion](/records/reasoning/node-ter-promotion)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-restore", "title": "RESTORE" }, { "blocks": [ { "entries": [ { "description": "Resource acquisition · lowers to READ_RESOURCE", "term": "Meaning" }, { "description": "LOAD config FROM file", "term": "Example" }, { "description": "[mode:observation](/records/reasoning/mode-observation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-load", "title": "LOAD" }, { "blocks": [ { "entries": [ { "description": "Communication · lowers to REPORT_RESULT", "term": "Meaning" }, { "description": "SEND message TO recipient", "term": "Example" }, { "description": "[axis:formalization](/records/reasoning/axis-formalization)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-send", "title": "SEND" }, { "blocks": [ { "entries": [ { "description": "action", "term": "Category" }, { "description": "Timing control · waiting has a command", "term": "Meaning" }, { "description": "WAIT FOR condition", "term": "Example" }, { "description": "[node:ter-block](/records/reasoning/node-ter-block)", "term": "Grounds" }, { "description": "coordination", "term": "Category" }, { "description": "Post and wait as one operation · reports the diff since this reader last looked", "term": "Meaning" }, { "description": "WAIT ON AS INTO ", "term": "Example" }, { "description": "[node:ter-block](/records/reasoning/node-ter-block)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-wait", "title": "WAIT" }, { "blocks": [ { "entries": [ { "description": "Trial operation", "term": "Meaning" }, { "description": "ATTEMPT operation", "term": "Example" }, { "description": "[mode:intervention](/records/reasoning/mode-intervention)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-attempt", "title": "ATTEMPT" }, { "blocks": [ { "entries": [ { "description": "Error termination · loud at the boundary", "term": "Meaning" }, { "description": "FAIL WITH message", "term": "Example" }, { "description": "[node:ver-refusal](/records/reasoning/node-ver-refusal)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-fail", "title": "FAIL" }, { "blocks": [ { "entries": [ { "description": "action", "term": "Category" }, { "description": "Exit execution", "term": "Meaning" }, { "description": "EXIT 1", "term": "Example" }, { "description": "[node:ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" }, { "description": "state_machine", "term": "Category" }, { "description": "Exit action", "term": "Meaning" }, { "description": "EXIT: cleanup", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-exit", "title": "EXIT" }, { "blocks": [ { "entries": [ { "description": "Return value · how a bounded reader ends", "term": "Meaning" }, { "description": "RETURN result", "term": "Example" }, { "description": "[node:ter-completion](/records/reasoning/node-ter-completion)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-return", "title": "RETURN" }, { "blocks": [ { "entries": [ { "description": "Repetition", "term": "Meaning" }, { "description": "ITERATE operation", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-iterate", "title": "ITERATE" }, { "blocks": [ { "entries": [ { "description": "Deep analysis", "term": "Meaning" }, { "description": "INVESTIGATE issue", "term": "Example" }, { "description": "[mode:observation](/records/reasoning/mode-observation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-investigate", "title": "INVESTIGATE" }, { "blocks": [ { "entries": [ { "description": "Decision making", "term": "Meaning" }, { "description": "DETERMINE outcome", "term": "Example" }, { "description": "[mode:classification](/records/reasoning/mode-classification)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-determine", "title": "DETERMINE" }, { "blocks": [ { "entries": [ { "description": "Constraint application", "term": "Meaning" }, { "description": "ENFORCE rule", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" }, { "description": "[ENFORCES](/records/pag/keyword-enforces): ENFORCE is an action a step invokes, while ENFORCES is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-enforce", "title": "ENFORCE" }, { "blocks": [ { "entries": [ { "description": "Proof provision", "term": "Meaning" }, { "description": "EVIDENCE claim", "term": "Example" }, { "description": "[node:ver-evidence](/records/reasoning/node-ver-evidence)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-evidence", "title": "EVIDENCE" }, { "blocks": [ { "entries": [ { "description": "Change distribution · the ripple through declared dependencies", "term": "Meaning" }, { "description": "PROPAGATE updates", "term": "Example" }, { "description": "[invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-propagate", "title": "PROPAGATE" }, { "blocks": [ { "entries": [ { "description": "Completion", "term": "Meaning" }, { "description": "FINALIZE operation", "term": "Example" }, { "description": "[node:ter-completion](/records/reasoning/node-ter-completion)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-finalize", "title": "FINALIZE" }, { "blocks": [ { "entries": [ { "description": "Aggregation · a fusion that drops nothing live", "term": "Meaning" }, { "description": "REDUCE items TO value", "term": "Example" }, { "description": "[mode:abstraction](/records/reasoning/mode-abstraction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-reduce", "title": "REDUCE" }, { "blocks": [ { "entries": [ { "description": "Name modification · every referencing surface enumerated first", "term": "Meaning" }, { "description": "RENAME file TO newname", "term": "Example" }, { "description": "[invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-rename", "title": "RENAME" }, { "blocks": [ { "entries": [ { "description": "Arrangement", "term": "Meaning" }, { "description": "ORDER items BY key", "term": "Example" }, { "description": "[lens:sequential](/records/reasoning/lens-sequential)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-order", "title": "ORDER" }, { "blocks": [ { "entries": [ { "description": "Annotation", "term": "Meaning" }, { "description": "MARK item AS complete", "term": "Example" }, { "description": "[axis:representation](/records/reasoning/axis-representation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-mark", "title": "MARK" }, { "blocks": [ { "entries": [ { "description": "Infer a future state", "term": "Meaning" }, { "description": "PREDICT outcome FROM model", "term": "Example" }, { "description": "[mode:prediction](/records/reasoning/mode-prediction)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-predict", "title": "PREDICT" }, { "blocks": [ { "entries": [ { "description": "Group by kind", "term": "Meaning" }, { "description": "CLASSIFY item BY type", "term": "Example" }, { "description": "[mode:classification](/records/reasoning/mode-classification)", "term": "Grounds" }, { "description": "[CLASSIFIES](/records/pag/keyword-classifies): CLASSIFY is an action a step invokes, while CLASSIFIES is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-classify", "title": "CLASSIFY" }, { "blocks": [ { "entries": [ { "description": "Identify the mechanism", "term": "Meaning" }, { "description": "EXPLAIN behavior", "term": "Example" }, { "description": "[mode:explanation](/records/reasoning/mode-explanation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-explain", "title": "EXPLAIN" }, { "blocks": [ { "entries": [ { "description": "Discover the principle behind the examples", "term": "Meaning" }, { "description": "REFLECT ON outcome", "term": "Example" }, { "description": "[mode:reflection](/records/reasoning/mode-reflection)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-reflect", "title": "REFLECT" }, { "blocks": [ { "entries": [ { "description": "Remove irrelevant detail", "term": "Meaning" }, { "description": "ABSTRACT pattern FROM cases", "term": "Example" }, { "description": "[mode:abstraction](/records/reasoning/mode-abstraction)", "term": "Grounds" }, { "description": "[ABSTRACTS](/records/pag/keyword-abstracts): ABSTRACT is an action a step invokes, while ABSTRACTS is the verb a document header uses to state what the document does.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-abstract", "title": "ABSTRACT" }, { "blocks": [ { "entries": [ { "description": "Extend examples into a principle", "term": "Meaning" }, { "description": "GENERALIZE FROM examples", "term": "Example" }, { "description": "[mode:generalization](/records/reasoning/mode-generalization)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-generalize", "title": "GENERALIZE" }, { "blocks": [ { "entries": [ { "description": "Characterize an object", "term": "Meaning" }, { "description": "DESCRIBE structure", "term": "Example" }, { "description": "[mode:description](/records/reasoning/mode-description)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-describe", "title": "DESCRIBE" }, { "blocks": [ { "entries": [ { "description": "Express symbolically", "term": "Meaning" }, { "description": "FORMALIZE rule AS predicate", "term": "Example" }, { "description": "[mode:formalization](/records/reasoning/mode-formalization)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-formalize", "title": "FORMALIZE" } ], "title": "action", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-control-flow", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Conditional execution", "term": "Meaning" }, { "description": "IF condition: action", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-if", "title": "IF" }, { "blocks": [ { "entries": [ { "description": "Alternative branch", "term": "Meaning" }, { "description": "ELSE: alternative", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-else", "title": "ELSE" }, { "blocks": [ { "entries": [ { "description": "control_flow", "term": "Category" }, { "description": "Iteration start", "term": "Meaning" }, { "description": "FOR EACH item IN list:", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" }, { "description": "contextual", "term": "Category" }, { "description": "Purpose/Iteration", "term": "Meaning" }, { "description": "SEARCH FOR pattern", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-for", "title": "FOR" }, { "blocks": [ { "entries": [ { "description": "Iterator marker", "term": "Meaning" }, { "description": "FOR EACH x IN items:", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-each", "title": "EACH" }, { "blocks": [ { "entries": [ { "description": "Conditional loop", "term": "Meaning" }, { "description": "WHILE condition: action", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-while", "title": "WHILE" }, { "blocks": [ { "entries": [ { "description": "Exception handling start", "term": "Meaning" }, { "description": "TRY: risky_op", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-try", "title": "TRY" }, { "blocks": [ { "entries": [ { "description": "Exception handler", "term": "Meaning" }, { "description": "CATCH: handle_error", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-catch", "title": "CATCH" }, { "blocks": [ { "entries": [ { "description": "Exception alternative", "term": "Meaning" }, { "description": "EXCEPT: recovery", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-except", "title": "EXCEPT" }, { "blocks": [ { "entries": [ { "description": "Cleanup block", "term": "Meaning" }, { "description": "FINALLY: cleanup", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-finally", "title": "FINALLY" }, { "blocks": [ { "entries": [ { "description": "Pattern matching", "term": "Meaning" }, { "description": "MATCH value:", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-match", "title": "MATCH" }, { "blocks": [ { "entries": [ { "description": "Match branch", "term": "Meaning" }, { "description": "CASE pattern: action", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-case", "title": "CASE" }, { "blocks": [ { "entries": [ { "description": "Fallback case · a declared default, never a masked failure", "term": "Meaning" }, { "description": "DEFAULT: fallback", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-default", "title": "DEFAULT" }, { "blocks": [ { "entries": [ { "description": "Event trigger", "term": "Meaning" }, { "description": "WHEN event: action", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-when", "title": "WHEN" }, { "blocks": [ { "entries": [ { "description": "Negated conditional", "term": "Meaning" }, { "description": "UNLESS condition: action", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-unless", "title": "UNLESS" }, { "blocks": [ { "entries": [ { "description": "Loop terminator", "term": "Meaning" }, { "description": "UNTIL done", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-until", "title": "UNTIL" }, { "blocks": [ { "entries": [ { "description": "Early exit check", "term": "Meaning" }, { "description": "GUARD cond ELSE: exit", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-guard", "title": "GUARD" }, { "blocks": [ { "entries": [ { "description": "Exit loop", "term": "Meaning" }, { "description": "BREAK", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-break", "title": "BREAK" }, { "blocks": [ { "entries": [ { "description": "Skip iteration", "term": "Meaning" }, { "description": "CONTINUE", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-continue", "title": "CONTINUE" }, { "blocks": [ { "entries": [ { "description": "Jump to label", "term": "Meaning" }, { "description": "GOTO label", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-goto", "title": "GOTO" }, { "blocks": [ { "entries": [ { "description": "Flow start marker", "term": "Meaning" }, { "description": "START process", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-start", "title": "START" }, { "blocks": [ { "entries": [ { "description": "Flow end marker", "term": "Meaning" }, { "description": "END", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-end", "title": "END" }, { "blocks": [ { "entries": [ { "description": "Termination", "term": "Meaning" }, { "description": "STOP", "term": "Example" }, { "description": "[node:ter-stop](/records/reasoning/node-ter-stop)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-stop", "title": "STOP" }, { "blocks": [ { "entries": [ { "description": "Loop marker", "term": "Meaning" }, { "description": "LOOP BACKTO step", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-loop", "title": "LOOP" }, { "blocks": [ { "entries": [ { "description": "Step marker", "term": "Meaning" }, { "description": "STEP 1: action", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-step", "title": "STEP" }, { "blocks": [ { "entries": [ { "description": "Rule definition", "term": "Meaning" }, { "description": "RULE name: body", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-rule", "title": "RULE" }, { "blocks": [ { "entries": [ { "description": "control_flow", "term": "Category" }, { "description": "Containment test", "term": "Meaning" }, { "description": "item IN collection", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" }, { "description": "contextual", "term": "Category" }, { "description": "Containment", "term": "Meaning" }, { "description": "FIND key IN object", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-in", "title": "IN" }, { "blocks": [ { "entries": [ { "description": "Pattern test", "term": "Meaning" }, { "description": "value MATCHES pattern", "term": "Example" }, { "description": "[representation:logic](/records/reasoning/representation-logic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-matches", "title": "MATCHES" } ], "title": "control_flow", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-declaration", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Variable assignment", "term": "Meaning" }, { "description": "SET name = value", "term": "Example" }, { "description": "[representation:symbolic](/records/reasoning/representation-symbolic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-set", "title": "SET" }, { "blocks": [ { "entries": [ { "description": "Typed declaration", "term": "Meaning" }, { "description": "DECLARE x: string", "term": "Example" }, { "description": "[representation:symbolic](/records/reasoning/representation-symbolic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-declare", "title": "DECLARE" }, { "blocks": [ { "entries": [ { "description": "Constant definition", "term": "Meaning" }, { "description": "DEFINE PI = 3.14", "term": "Example" }, { "description": "[representation:symbolic](/records/reasoning/representation-symbolic)", "term": "Grounds" }, { "description": "[DEFINES](/records/pag/keyword-defines): DEFINE declares a constant inside a document, while DEFINES is the verb a document header uses to state what the document specifies.", "term": "Distinct from" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-define", "title": "DEFINE" }, { "blocks": [ { "entries": [ { "description": "Local binding", "term": "Meaning" }, { "description": "LET temp = expr", "term": "Example" }, { "description": "[representation:symbolic](/records/reasoning/representation-symbolic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-let", "title": "LET" }, { "blocks": [ { "entries": [ { "description": "Immutable value", "term": "Meaning" }, { "description": "CONST MAX = 100", "term": "Example" }, { "description": "[representation:symbolic](/records/reasoning/representation-symbolic)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-const", "title": "CONST" } ], "title": "declaration", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-modifier", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Mandatory requirement · a modifier inside a property", "term": "Meaning" }, { "description": "MUST validate first", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-must", "title": "MUST" }, { "blocks": [ { "entries": [ { "description": "Prohibition · a modifier inside a property", "term": "Meaning" }, { "description": "NEVER delete without backup", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-never", "title": "NEVER" }, { "blocks": [ { "entries": [ { "description": "Invariance · a modifier inside a property", "term": "Meaning" }, { "description": "ALWAYS log changes", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-always", "title": "ALWAYS" }, { "blocks": [ { "entries": [ { "description": "Necessity marker", "term": "Meaning" }, { "description": "REQUIRED field", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-required", "title": "REQUIRED" }, { "blocks": [ { "entries": [ { "description": "Obligation marker", "term": "Meaning" }, { "description": "MANDATORY check", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-mandatory", "title": "MANDATORY" }, { "blocks": [ { "entries": [ { "description": "Repair ordering among failures, never a softer verdict", "term": "Meaning" }, { "description": "CRITICAL validation", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-critical", "title": "CRITICAL" }, { "blocks": [ { "entries": [ { "description": "No exceptions", "term": "Meaning" }, { "description": "ABSOLUTE rule", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-absolute", "title": "ABSOLUTE" }, { "blocks": [ { "entries": [ { "description": "Absolute prohibition", "term": "Meaning" }, { "description": "FORBIDDEN: direct DB", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-forbidden", "title": "FORBIDDEN" } ], "title": "modifier", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-coordination", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Async wait · waiting has a command, a turn never ends to wait", "term": "Meaning" }, { "description": "AWAIT op INTO result", "term": "Example" }, { "description": "[node:ter-block](/records/reasoning/node-ter-block)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-await", "title": "AWAIT" }, { "blocks": [ { "entries": [ { "description": "Concurrent execution", "term": "Meaning" }, { "description": "PARALLEL: tasks END", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-parallel", "title": "PARALLEL" }, { "blocks": [ { "entries": [ { "description": "Task handoff · a bounded reader receives a task and returns", "term": "Meaning" }, { "description": "DELEGATE task TO reader", "term": "Example" }, { "description": "[model:cognition](/records/reasoning/model-cognition)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-delegate", "title": "DELEGATE" }, { "blocks": [ { "entries": [ { "description": "Task queuing", "term": "Meaning" }, { "description": "QUEUE operation", "term": "Example" }, { "description": "[representation:computation](/records/reasoning/representation-computation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-queue", "title": "QUEUE" }, { "blocks": [ { "entries": [ { "description": "Retry on failure · bounded by a declared limit", "term": "Meaning" }, { "description": "RETRY operation", "term": "Example" }, { "description": "[node:ter-diminishing-returns](/records/reasoning/node-ter-diminishing-returns)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-retry", "title": "RETRY" }, { "blocks": [ { "entries": [ { "description": "Resource lock · the barrier around an exclusive write", "term": "Meaning" }, { "description": "LOCK resource", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-lock", "title": "LOCK" }, { "blocks": [ { "entries": [ { "description": "Release lock", "term": "Meaning" }, { "description": "UNLOCK resource", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-unlock", "title": "UNLOCK" }, { "blocks": [ { "entries": [ { "description": "A file parties read and write · its key declared in the header, never derived from the path", "term": "Meaning" }, { "description": "SURFACE :", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-surface", "title": "SURFACE" }, { "blocks": [ { "entries": [ { "description": "One addressable claim inside a surface · exactly one writer", "term": "Meaning" }, { "description": "RECORD subject: ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-record", "title": "RECORD" }, { "blocks": [ { "entries": [ { "description": "An addressed span inside a record · its id allocated by the tool", "term": "Meaning" }, { "description": "ITEM TO : ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-item", "title": "ITEM" }, { "blocks": [ { "entries": [ { "description": "Edge · the target reduces this surface upward", "term": "Meaning" }, { "description": "PARENT ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-parent", "title": "PARENT" }, { "blocks": [ { "entries": [ { "description": "Edge · the record resolves when the artifact exists", "term": "Meaning" }, { "description": "SATISFIED_BY ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-satisfied-by", "title": "SATISFIED_BY" }, { "blocks": [ { "entries": [ { "description": "Edge · the target cannot close first", "term": "Meaning" }, { "description": "BLOCKS ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-blocks", "title": "BLOCKS" }, { "blocks": [ { "entries": [ { "description": "Edge · this record acts on the target", "term": "Meaning" }, { "description": "ANSWERS ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-answers", "title": "ANSWERS" }, { "blocks": [ { "entries": [ { "description": "Edge · this record contradicts the target with evidence", "term": "Meaning" }, { "description": "REFUTES ", "term": "Example" }, { "description": "[node:ver-refutation](/records/reasoning/node-ver-refutation)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-refutes", "title": "REFUTES" }, { "blocks": [ { "entries": [ { "description": "Edge · this record replaces the target", "term": "Meaning" }, { "description": "SUPERSEDES ", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-supersedes", "title": "SUPERSEDES" }, { "blocks": [ { "entries": [ { "description": "Derived state · an unresolved outbound edge, never written", "term": "Meaning" }, { "description": "state: OPEN", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-open", "title": "OPEN" }, { "blocks": [ { "entries": [ { "description": "Derived state · the satisfying artifact exists, so it is extracted, then deleted", "term": "Meaning" }, { "description": "state: ABSORBED", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-absorbed", "title": "ABSORBED" }, { "blocks": [ { "entries": [ { "description": "A party's class, derived from what it received · participant or bounded", "term": "Meaning" }, { "description": "READER AS participant | bounded", "term": "Example" }, { "description": "[model:cognition](/records/reasoning/model-cognition)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-reader", "title": "READER" }, { "blocks": [ { "entries": [ { "description": "Proceed with an exclusive write only once every peer is parked", "term": "Meaning" }, { "description": "BARRIER ON ", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-barrier", "title": "BARRIER" }, { "blocks": [ { "entries": [ { "description": "Compare-and-swap on the writer's own span · refuses an overlap with its diff", "term": "Meaning" }, { "description": "SWAP ** AGAINST ******", "term": "Example" }, { "description": "[substrate-node:constraint](/records/reasoning/substrate-node-constraint)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-swap", "title": "SWAP" } ], "title": "coordination", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-state-machine", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Machine declaration · makes a lifetime or a derived-state set explicit", "term": "Meaning" }, { "description": "STATE_MACHINE workflow:", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-state-machine", "title": "STATE_MACHINE" }, { "blocks": [ { "entries": [ { "description": "State definition · a state is derived from the graph, never written", "term": "Meaning" }, { "description": "STATE pending:", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-state", "title": "STATE" }, { "blocks": [ { "entries": [ { "description": "State change rule", "term": "Meaning" }, { "description": "TRANSITION FROM a TO b", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-transition", "title": "TRANSITION" }, { "blocks": [ { "entries": [ { "description": "Event trigger", "term": "Meaning" }, { "description": "ON approval", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-on", "title": "ON" }, { "blocks": [ { "entries": [ { "description": "state_machine", "term": "Category" }, { "description": "Source state", "term": "Meaning" }, { "description": "FROM pending", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" }, { "description": "contextual", "term": "Category" }, { "description": "Source", "term": "Meaning" }, { "description": "EXTRACT FROM response", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-from", "title": "FROM" }, { "blocks": [ { "entries": [ { "description": "state_machine", "term": "Category" }, { "description": "Target state", "term": "Meaning" }, { "description": "TO approved", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" }, { "description": "contextual", "term": "Category" }, { "description": "Target", "term": "Meaning" }, { "description": "WRITE TO file", "term": "Example" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-to", "title": "TO" }, { "blocks": [ { "entries": [ { "description": "Entry action", "term": "Meaning" }, { "description": "ENTRY: notify", "term": "Example" }, { "description": "[representation:dynamical-systems](/records/reasoning/representation-dynamical-systems)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-entry", "title": "ENTRY" } ], "title": "state_machine", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-dag", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Graph declaration · makes a dependency graph explicit, and the loop spine is one", "term": "Meaning" }, { "description": "DAG pipeline:", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph), [invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-dag", "title": "DAG" }, { "blocks": [ { "entries": [ { "description": "Dependencies · declared by the referent, never inferred from a name", "term": "Meaning" }, { "description": "DEPENDS_ON [a, b]", "term": "Example" }, { "description": "[invariant:epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-depends-on", "title": "DEPENDS_ON" }, { "blocks": [ { "entries": [ { "description": "Sequencing", "term": "Meaning" }, { "description": "AFTER compile", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-after", "title": "AFTER" }, { "blocks": [ { "entries": [ { "description": "Reverse sequencing", "term": "Meaning" }, { "description": "BEFORE deploy", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-before", "title": "BEFORE" }, { "blocks": [ { "entries": [ { "description": "Parallel nodes · peers with no edge between them", "term": "Meaning" }, { "description": "PARALLEL_GROUP: a, b", "term": "Example" }, { "description": "[representation:graph](/records/reasoning/representation-graph)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-parallel-group", "title": "PARALLEL_GROUP" } ], "title": "dag", "kind": "keywords" }, { "icon": "bi-code-square", "id": "pag-keywords-priority-queue", "intro": "Every PAG keyword record, with what grounds it and how it is checked.", "subsections": [ { "blocks": [ { "entries": [ { "description": "Queue declaration · makes a ranking explicit, and the branch ranking a worth gate emits is one", "term": "Meaning" }, { "description": "PRIORITY_QUEUE branches:", "term": "Example" }, { "description": "[node:tel-priority](/records/reasoning/node-tel-priority)", "term": "Grounds" } ], "kind": "glossary" }, { "kind": "text", "text": "How it is checked" }, { "entries": [ { "description": "a structured-document validator that parses each document against the grammar and reports every defect by its shape", "term": "Checked by" }, { "description": "Every agent and template document the validator walks, and every occurrence of the keyword in them", "term": "Population" }, { "description": "A verdict stands until the grammar data or a document that uses the keyword changes", "term": "Freshness" }, { "description": "The validation stage fails the gate on any defect code, so a document with a malformed keyword does not ship", "term": "Refusal" }, { "description": "None, because a keyword is static text in a document, and nothing observes it while a run executes", "term": "Observation" }, { "description": "Watched to fire and to accept: a suite plants a retired head in a real template and validates every agent and template on disk clean", "term": "Evidence" }, { "description": "The grammar data, which every keyword in a document conforms to", "term": "Authoritative side" }, { "description": "Not answered", "term": "Depends on" }, { "description": "Not answered", "term": "Shape it refuses" } ], "kind": "glossary" } ], "id": "pag-keyword-priority-queue", "title": "PRIORITY_QUEUE" }, { "blocks": [ { "entries": [ { "description": "priority_queue", "term": "Category" }, { "description": "Priority value · utility minus cost", "term": "Meaning" }, { "description": "PRIORITY = 10", "term": "Example" }, { "description": "[node:tel-utility](/records/reasoning/node-tel-utility), [node:tel-cost](/records/reasoning/node-tel-cost)", "term": "Grounds" }, { "description": "meta", "term": "Category" }, { "description": "The authority tiers · which source grounds which, highest first", "term": "Meaning" }, { "description": "priority: > >